一、前言
1、背景
在code review的时候，发现项目中有如下代码：
// GetUpdateFieldStr 组装更新的sql和参数
func GetUpdateFieldStr(ctx context.Context, updateFields *infra.UpdateFeilds) (sqlUpdate string, args []interface{}) {
// 拼接update字段
log.Debugf("getUpdateFieldStr: (%#v)", updateFields)
sqlUpdate = ""
// 拼接update字段
if updateFields.MapId != "" {
sqlUpdate += " map_id = ?,"
args = append(args, updateFields.MapId)
}
if updateFields.ObjBase != "" {
sqlUpdate += " obj_base = ?,"
args = append(args, updateFields.ObjBase)
}
....
log.Debugf("sqlUpdate : %s,args:(%#v)", sqlUpdate, args)
return
}
// GetSqlWhereStr 组装where条件和参数
func GetSqlWhereStr(ctx context.Context, wheres *infra.WhereFields) (sqlWhere string, args []interface{}) {}
项目中使用的是sqlx来进行增删改查，一般来说sqlx相对于orm来说是比较原始的，要自己写sql或者封装方法去拼接sql，但是上面的代码存在几个问题。
1、表字段越多，函数越长，出错概率越大
2、多个表的话，这两个方法就会不断增大，冗余
3、如果是要把字段更新为空，比如字符串类型的字段，目标就是更新成""空字符串，以上方法明显是不符合的。
而针对以上代码，比较好的方式就是用builder生成器模式去做，构造一个builder对象，不断的通过链式调用去拼接字段，最终通过build()方法来输出即可。周末闲着没事，那就重构一下吧。
2、生成器模式
参考：
golang实现生成器模式1
golang实现生成器模式2
golang实现生成器模式3
生成器模式的目标：
- 将复杂对象的构造与其表示分开。
- 允许相同的构建过程创建不同的表示。
- 将构造逻辑封装在单独的构建器类中。
- 允许创建具有许多可选或变化部分的对象。
二、builder生成sql语句
1、定义要生成的对象和builder
package mysql
import (
"strings"
)
// SqlClause 定义要生成的对象，组装表sql
type SqlClause struct {
table string
sql string
args []interface{}
}
// 为了节省空间，具体的SelectBuilder暂时不写
type SelectInterface interface {
Select(field string) SelectInterface
Count(field string) SelectInterface
Build() (sql string, args []interface{})
}
// 定义update语句的接口
type UpdateInterface interface {
Update(field string, value interface{}) UpdateInterface
Build() (sql string, args []interface{})
}
// 定义where语句的接口
type WhereInterface interface {
Where(field string, value interface{}) WhereInterface
In(field string, valStr string) WhereInterface
Build() (sql string, args []interface{})
}
// UpdateBuilder update语句生成器
type UpdateBuilder struct {
UpdateSql *SqlClause
WhereSql *WhereBuilder
}
func NewUpdateBuilder(table string) *UpdateBuilder {
return &UpdateBuilder{
UpdateSql: &SqlClause{
table: table,
sql: "update " + table + " set ",
args: make([]interface{}, 0),
},
WhereSql: NewWhereBuilder(),
}
}
// 通过update语句组装
func (u *UpdateBuilder) Update(field string, value interface{}) UpdateInterface {
u.UpdateSql.sql += " " + field + " = ?,"
u.UpdateSql.args = append(u.UpdateSql.args, value)
return u
}
// 输出完整的update语句
func (u *UpdateBuilder) Build() (sql string, args []interface{}) {
if len(u.UpdateSql.args) < 1 {
return
}
if len(u.WhereSql.sqlClause.args) < 1 {
return
}
// 拼接sql
sql = strings.TrimRight(u.UpdateSql.sql, ", ")
args = append(args, u.UpdateSql.args...)
sql += strings.TrimRight(u.WhereSql.sqlClause.sql, "and ")
args = append(args, u.WhereSql.sqlClause.args...)
return
}
// WhereBuilder where语句生成器
type WhereBuilder struct {
sqlClause *SqlClause
}
func NewWhereBuilder() *WhereBuilder {
return &WhereBuilder{
sqlClause: &SqlClause{
sql: " where ",
args: make([]interface{}, 0),
},
}
}
// 通用where条件组装
func (w *WhereBuilder) Where(field string, value interface{}) WhereInterface {
w.sqlClause.sql += " " + field + " = ? and "
w.sqlClause.args = append(w.sqlClause.args, value)
return w
}
// where语句的in查询
func (w *WhereBuilder) In(field string, valStr string) WhereInterface {
fieldSlice := strings.Split(valStr, ",")
var inStr string
for i, v := range fieldSlice {
if i == 0 {
inStr = "?"
} else {
inStr += ", ?"
}
w.sqlClause.args = append(w.sqlClause.args, v)
}
w.sqlClause.sql += " " + field + " in ( " + inStr + ") and "
return w
}
// 输出结果
func (w *WhereBuilder) Build() (sql string, args []interface{}) {
if len(w.sqlClause.args) < 1 {
return
}
// 拼接where sql
sqlWhere := strings.TrimRight(w.sqlClause.sql, "and ")
sql += sqlWhere
args = append(args, w.sqlClause.args...)
return
}
2、每个表基于自己的字段实现细节
// =========================== table级别方法 =================================
// MappingTaskBuilder map表的builder，组装select,update等sql，调用方式如下:
// 完整的update sql : MappingTaskBuilder.Update().UpdatemapId().WhereTaskId().Build()
// 完整的select sql : MappingTaskBuilder.Select().SelectFields().WhereTaskId().Build()
// 单独的where sql : MappingTaskBuilder.WhereCodes().WhereTaskId().BuildWhereSql()
type MappingTaskBuilder struct {
updateBuilder *mysql.UpdateBuilder
selectBuilder *mysql.SelectBuilder
whereBuilder *mysql.WhereBuilder
}
func NewMappingTaskBuilder() *MappingTaskBuilder {
return &MappingTaskBuilder{
whereBuilder: mysql.NewWhereBuilder(),
}
}
func (m *MappingTaskBuilder) Update(table string) *MappingTaskBuilder {
m.updateBuilder = mysql.NewUpdateBuilder(table)
return m
}
func (m *MappingTaskBuilder) Select(table string) *MappingTaskBuilder {
m.selectBuilder = mysql.NewSelectBuilder(table)
return m
}
// ------- update条件，定义具体字段所属函数是为了编码的清晰
// map_id
func (m *MappingTaskBuilder) UpdateMapId(field string, value interface{}) *MappingTaskBuilder {
m.updateBuilder.Update(field, value)
return m
}
// obj_base
func (m *MappingTaskBuilder) UpdateObjBase(field string, value interface{}) *MappingTaskBuilder {
m.updateBuilder.Update(field, value)
return m
}
// ---- select条件,可以传单个字段，也可以一次性传输
// Select 组装select语句,selectStr为空则返回
func (m *MappingTaskBuilder) SelectFields(selectStr string) *MappingTaskBuilder {
if selectStr == "" {
return m
}
m.selectBuilder.Select(selectStr)
return m
}
// ---- where条件
// codes
func (m *MappingTaskBuilder) WhereCodes(field string, valStr string) *MappingTaskBuilder {
m.whereBuilder.In(field, valStr)
return m
}
// task_id
func (m *MappingTaskBuilder) WhereTaskId(field string, value interface{}) *MappingTaskBuilder {
m.whereBuilder.Where(field, value)
return m
}
// --------- 输出
// 输出完整update语句
func (m *MappingTaskBuilder) BuildUpdateSql() (sql string, args []interface{}) {
// where语句赋值
m.updateBuilder.WhereSql = m.whereBuilder
sql, args = m.updateBuilder.Build()
return
}
// 输出完整select语句
func (m *MappingTaskBuilder) BuildSelectSql() (sql string, args []interface{}) {
// where语句赋值
m.selectBuilder.WhereSql = m.whereBuilder
sql, args = m.selectBuilder.Build()
return
}
// 输出 where的sql
func (m *MappingTaskBuilder) BuildWhereSql() (sql string, args []interface{}) {
sql, args = m.whereBuilder.Build()
return
}
// 输出完整的sql
func (m *MappingTaskBuilder) Build() (sql string, args []interface{}) {
if m.selectBuilder == nil && m.updateBuilder == nil {
return
}
if m.selectBuilder == nil {
return m.BuildUpdateSql()
}
if m.updateBuilder == nil {
return m.BuildSelectSql()
}
// 没有设置update和select则只输出where sql语句
return m.BuildWhereSql()
}
// Reset 重置
func (m *MappingTaskBuilder) Reset() {
m = nil
}
3、调用方式
builder := xengine.NewMappingTaskBuilder()
sqlUpdate, args = builder.Update("mapping_task").
UpdateMapId("map_id", updateFields.MapId).
UpdateObjBase("obj_base", updateFields.ObjBase).
WhereMapId("map_id", wheres.MapId).
WhereDel("del", wheres.Del).
Builder()
三、一些思考
写完以上代码之后发现这跟orm有点像啊，每个表都是一个对象，通过链式调用组装和执行sql… 我们上面的封装就是最简单的组装sql。
某种意义上也说明是技术选型的问题，业务没那么复杂的情况下，选用orm虽然重一点，但起码代码是便于编写和方便维护的。sqlx在复杂sql比如统计类项目中还是可以的，动不动几十行的sql起步，用orm就有些痛苦了。
可惜项目已经成型，想换个sql引擎改动实在有点大，那就只能不断的提升代码水平了，不然code review实在是一种折磨。。
======== 20230715更新 =============
最近又对以上代码进行了迭代，包括新增hash支持字段值覆盖，build函数统一组装。以及where中order by，limit，group by的支持等，整体来说越来越偏orm的操作。。。所以仁者见仁智者见智了，建议简单sql直接orm一了百了。
end
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
