builder where & update support Raw SQL (#147)

* where & update support Raw SQL

* fix

* fix

* builder where & update support Raw SQL

* builder where & update support Raw SQL

* add unittests

README.md

@@ -83,6 +83,20 @@ cond, values, err := builder.BuildSelect(table, where, selectFields)
 //values = []interface{}{11, 45, "234", "tx2", 5, "beijing", "shanghai", 35}
 
 rows, err := db.Query(cond, values...)
+
+
+// support builder.Raw in where & update
+where := map[string]interface{}{"gmt_create <": builder.Raw("gmt_modified")}
+cond, values, err := builder.BuildSelect(table, where, selectFields)
+// SELECT * FROM x WHERE gmt_create < gmt_modified
+
+update = map[string]interface{}{
+    "code": builder.Raw("VALUES(code)"), // mysql 8.x  builder.Raw("new.code")
+    "name": builder.Raw("VALUES(name)"), // mysql 8.x  builder.Raw("new.name")
+}
+cond, values, err := builder.BuildInsertOnDuplicate(table, data, update)
+// INSERT INTO country (id, code, name) VALUES (?,?,?),(?,?,?),(?,?,?) 
+// ON DUPLICATE KEY UPDATE code=VALUES(code),name=VALUES(name)
 ```
 
 In the `where` param, `in` operator is automatically added by value type(reflect.Slice).

builder/README.md

@@ -26,6 +26,7 @@ func main() {
         "country": "China",
         "role": "driver",
         "age >": 45,
+        "gmt_create <": builder.Raw("gmt_modified"),
         "_or": []map[string]interface{}{
             {
                 "x1":    11,
@@ -45,7 +46,7 @@ func main() {
     }
     cond,vals,err := qb.BuildSelect("tableName", where, []string{"name", "count(price) as total", "age"})
 
-    //cond: SELECT name,count(price) as total,age FROM tableName WHERE (((x1=? AND x2>=?) OR (x3=? AND x4!=?)) AND country=? AND role=? AND age>?) GROUP BY name HAVING (total>? AND total<=?) ORDER BY age DESC
+    //cond: SELECT name,count(price) as total,age FROM tableName WHERE (((x1=? AND x2>=?) OR (x3=? AND x4!=?)) AND country=? AND gmt_create < gmt_modified AND role=? AND age>?) GROUP BY name HAVING (total>? AND total<=?) ORDER BY age DESC
     //vals: []interface{}{11, 45, "234", "tx2", "China", "driver", 45, 1000, 50000}
 
 	if nil != err {
@@ -287,6 +288,16 @@ update := map[string]interface{}{
 }
 cond, vals, err := qb.BuildInsertOnDuplicate(table, data, update)
 db.Exec(cond, vals...)
+
+
+// update support builder.Raw to update when duplicate with value in insert data
+update = map[string]interface{}{
+    "code": builder.Raw("VALUES(code)"), // mysql 8.x  builder.Raw("new.code")
+    "name": builder.Raw("VALUES(name)"), // mysql 8.x  builder.Raw("new.name")
+}
+cond, values, err := builder.BuildInsertOnDuplicate(table, data, update)
+// INSERT INTO country (id, code, name) VALUES (?,?,?),(?,?,?),(?,?,?) 
+// ON DUPLICATE KEY UPDATE code=VALUES(code),name=VALUES(name)
 ```
 
 #### `NamedQuery`

builder/builder.go

@@ -35,6 +35,8 @@ var (
 	}
 )
 
+type Raw string
+
 type whereMapSet struct {
 	set map[string]map[string]interface{}
 }

builder/builder_test.go

@@ -608,7 +608,7 @@ func Test_BuildSelect(t *testing.T) {
 	}
 }
 
-func Test_BuildSelectMutliOr(t *testing.T) {
+func Test_BuildSelectMultiOr(t *testing.T) {
 	type inStruct struct {
 		table  string
 		where  map[string]interface{}

builder/dao.go

@@ -302,15 +302,20 @@ func build(m map[string]interface{}, op string) ([]string, []interface{}) {
 	}
 	length := len(m)
 	cond := make([]string, length)
-	vals := make([]interface{}, length)
+	vals := make([]interface{}, 0, length)
 	var i int
 	for key := range m {
 		cond[i] = key
 		i++
 	}
 	defaultSortAlgorithm(cond)
 	for i = 0; i < length; i++ {
-		vals[i] = m[cond[i]]
+		v := m[cond[i]]
+		if raw, ok := v.(Raw); ok {
+			cond[i] += op + string(raw)
+			continue
+		}
+		vals = append(vals, v)
 		cond[i] = assembleExpression(cond[i], op)
 	}
 	return cond, vals
@@ -320,17 +325,6 @@ func assembleExpression(field, op string) string {
 	return quoteField(field) + op + "?"
 }
 
-func resolveKV(m map[string]interface{}) (keys []string, vals []interface{}) {
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		vals = append(vals, m[k])
-	}
-	return
-}
-
 func resolveFields(m map[string]interface{}) []string {
 	var fields []string
 	for k := range m {
@@ -409,13 +403,23 @@ func buildInsertOnDuplicate(table string, data []map[string]interface{}, update
 	return cond, vals, nil
 }
 
-func resolveUpdate(update map[string]interface{}) (string, []interface{}) {
-	keys, vals := resolveKV(update)
-	var sets string
+func resolveUpdate(update map[string]interface{}) (sets string, vals []interface{}) {
+	keys := make([]string, 0, len(update))
+	for key := range update {
+		keys = append(keys, key)
+	}
+	defaultSortAlgorithm(keys)
+	var sb strings.Builder
 	for _, k := range keys {
-		sets += fmt.Sprintf("%s=?,", quoteField(k))
+		v := update[k]
+		if _, ok := v.(Raw); ok {
+			sb.WriteString(fmt.Sprintf("%s=%s,", k, v))
+			continue
+		}
+		vals = append(vals, v)
+		sb.WriteString(fmt.Sprintf("%s=?,", quoteField(k)))
 	}
-	sets = strings.TrimRight(sets, ",")
+	sets = strings.TrimRight(sb.String(), ",")
 	return sets, vals
 }
 

builder/dao_test.go

@@ -21,11 +21,18 @@ func TestEq(t *testing.T) {
 			[]string{"baz=?", "foo=?", "qq=?"},
 			[]interface{}{1, "bar", "ttx"},
 		},
+		{
+			map[string]interface{}{
+				"gmt_create": Raw("gmt_modified"),
+				"status":     1,
+			},
+			[]string{"gmt_create=gmt_modified", "status=?"},
+			[]interface{}{1},
+		},
 	}
 	ass := assert.New(t)
 	for _, testCase := range testData {
 		cond, vals := Eq(testCase.in).Build()
-		ass.Equal(len(cond), len(vals))
 		ass.Equal(testCase.outCon, cond)
 		ass.Equal(testCase.outVal, vals)
 	}
@@ -111,33 +118,51 @@ func TestAssembleExpression(t *testing.T) {
 	}
 }
 
-func TestResolveKV(t *testing.T) {
+func TestResolveUpdate(t *testing.T) {
 	var data = []struct {
 		in      map[string]interface{}
-		outStr  []string
+		outStr  string
 		outVals []interface{}
 	}{
 		{
-			map[string]interface{}{
+			in: map[string]interface{}{
 				"foo": "bar",
 				"bar": 1,
 			},
-			[]string{"bar", "foo"},
-			[]interface{}{1, "bar"},
+			outStr:  "bar=?,foo=?",
+			outVals: []interface{}{1, "bar"},
 		},
 		{
-			map[string]interface{}{
+			in: map[string]interface{}{
 				"qq":    "ttt",
 				"some":  123,
 				"other": 456,
 			},
-			[]string{"other", "qq", "some"},
-			[]interface{}{456, "ttt", 123},
+			outStr:  "other=?,qq=?,some=?",
+			outVals: []interface{}{456, "ttt", 123},
+		},
+		{
+			in: map[string]interface{}{ // mysql5.7
+				"id":   1,
+				"name": Raw("VALUES(name)"),
+				"age":  Raw("VALUES(age)"),
+			},
+			outStr:  "age=VALUES(age),id=?,name=VALUES(name)",
+			outVals: []interface{}{1},
+		},
+		{
+			in: map[string]interface{}{ // mysql8.0
+				"id":   1,
+				"name": Raw("new.name"),
+				"age":  Raw("new.age"),
+			},
+			outStr:  "age=new.age,id=?,name=new.name",
+			outVals: []interface{}{1},
 		},
 	}
 	ass := assert.New(t)
 	for _, tc := range data {
-		keys, vals := resolveKV(tc.in)
+		keys, vals := resolveUpdate(tc.in)
 		ass.Equal(tc.outStr, keys)
 		ass.Equal(tc.outVals, vals)
 	}
@@ -281,11 +306,12 @@ func TestBuildInsertOnDuplicate(t *testing.T) {
 				},
 			},
 			update: map[string]interface{}{
+				"a": Raw("VALUES(a)"),
 				"b": 7,
 				"c": 8,
 			},
 			outErr:  nil,
-			outStr:  "INSERT INTO tb (a,b,c) VALUES (?,?,?),(?,?,?) ON DUPLICATE KEY UPDATE b=?,c=?",
+			outStr:  "INSERT INTO tb (a,b,c) VALUES (?,?,?),(?,?,?) ON DUPLICATE KEY UPDATE a=VALUES(a),b=?,c=?",
 			outVals: []interface{}{1, 2, 3, 4, 5, 6, 7, 8},
 		},
 	}
@@ -316,11 +342,12 @@ func TestBuildUpdate(t *testing.T) {
 				}),
 			},
 			data: map[string]interface{}{
-				"name": "deen",
-				"age":  23,
+				"name":  "deen",
+				"age":   23,
+				"count": Raw("count+1"),
 			},
 			outErr:  nil,
-			outStr:  "UPDATE tb SET age=?,name=? WHERE (foo=? AND qq=?)",
+			outStr:  "UPDATE tb SET age=?,count=count+1,name=? WHERE (foo=? AND qq=?)",
 			outVals: []interface{}{23, "deen", "bar", 1},
 		},
 	}
@@ -345,12 +372,13 @@ func TestBuildDelete(t *testing.T) {
 			table: "tb",
 			where: []Comparable{
 				Eq(map[string]interface{}{
-					"foo": 1,
-					"bar": 2,
-					"baz": "tt",
+					"foo":        1,
+					"bar":        2,
+					"baz":        "tt",
+					"gmt_create": Raw("gmt_modified"),
 				}),
 			},
-			outStr:  "DELETE FROM tb WHERE (bar=? AND baz=? AND foo=?)",
+			outStr:  "DELETE FROM tb WHERE (bar=? AND baz=? AND foo=? AND gmt_create=gmt_modified)",
 			outVals: []interface{}{2, "tt", 1},
 			outErr:  nil,
 		},
@@ -384,6 +412,7 @@ func TestBuildSelect(t *testing.T) {
 				Eq(map[string]interface{}{
 					"foo": 1,
 					"bar": 2,
+					"tm":  Raw("NOW()"),
 				}),
 				In(map[string][]interface{}{
 					"qq": {4, 5, 6},
@@ -415,7 +444,7 @@ func TestBuildSelect(t *testing.T) {
 			},
 			lockMode: "exclusive",
 			outErr:   nil,
-			outStr:   "SELECT foo,bar FROM tb WHERE (bar=? AND foo=? AND qq IN (?,?,?) AND ((aa=? AND bb=?) OR (cc=? AND dd=?))) ORDER BY foo DESC,baz ASC LIMIT ?,? FOR UPDATE",
+			outStr:   "SELECT foo,bar FROM tb WHERE (bar=? AND foo=? AND tm=NOW() AND qq IN (?,?,?) AND ((aa=? AND bb=?) OR (cc=? AND dd=?))) ORDER BY foo DESC,baz ASC LIMIT ?,? FOR UPDATE",
 			outVals:  []interface{}{2, 1, 4, 5, 6, 3, 4, 7, 8, 10, 20},
 		},
 	}