feature: new builder WhereClause dedicated for WHERE

Author: huandu

README.md

@@ -10,6 +10,7 @@
   - [Basic usage](#basic-usage)
   - [Pre-defined SQL builders](#pre-defined-sql-builders)
   - [Build `WHERE` clause](#build-where-clause)
+  - [Share `WHERE` clause among builders](#share-where-clause-among-builders)
   - [Build SQL for different systems](#build-sql-for-different-systems)
   - [Using `Struct` as a light weight ORM](#using-struct-as-a-light-weight-orm)
   - [Nested SQL](#nested-sql)
@@ -138,12 +139,12 @@ fmt.Println(args)
 
 There are many methods for building conditions.
 
-- [Cond.Equal](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.Equal)/[Cond.E](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.E): `field = value`.
-- [Cond.NotEqual](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NotEqual)/[Cond.NE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NE): `field <> value`.
-- [Cond.GreaterThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GreaterThan)/[Cond.G](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.G): `field > value`.
-- [Cond.GreaterEqualThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GreaterEqualThan)/[Cond.GE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GE): `field >= value`.
-- [Cond.LessThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LessThan)/[Cond.L](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.L): `field < value`.
-- [Cond.LessEqualThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LessEqualThan)/[Cond.LE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LE): `field <= value`.
+- [Cond.Equal](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.Equal)/[Cond.E](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.E)/[Cond.EQ](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.EQ): `field = value`.
+- [Cond.NotEqual](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NotEqual)/[Cond.NE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NE)/[Cond.NEQ](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NEQ): `field <> value`.
+- [Cond.GreaterThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GreaterThan)/[Cond.G](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.G)/[Cond.GT](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GT): `field > value`.
+- [Cond.GreaterEqualThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GreaterEqualThan)/[Cond.GE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GE)/[Cond.GTE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.GTE): `field >= value`.
+- [Cond.LessThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LessThan)/[Cond.L](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.L)/[Cond.LT](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LT): `field < value`.
+- [Cond.LessEqualThan](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LessEqualThan)/[Cond.LE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LE)/[Cond.LTE](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.LTE): `field <= value`.
 - [Cond.In](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.In): `field IN (value1, value2, ...)`.
 - [Cond.NotIn](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.NotIn): `field NOT IN (value1, value2, ...)`.
 - [Cond.Like](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.Like): `field LIKE value`.
@@ -164,6 +165,36 @@ There are also some methods to combine conditions.
 - [Cond.And](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.And): Combine conditions with `AND` operator.
 - [Cond.Or](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Cond.Or): Combine conditions with `OR` operator.
 
+### Share `WHERE` clause among builders
+
+Due to the importance of the `WHERE` statement in SQL, we often need to continuously append conditions and even share some common `WHERE` conditions among different builders. Therefore, we abstract the `WHERE` statement into a `WhereClause` struct, which can be used to create reusable `WHERE` conditions.
+
+Here is a sample to show how to copy `WHERE` clause from a `SelectBuilder` to an `UpdateBuilder`.
+
+```go
+// Build a SQL to select a user from database.
+sb := Select("name", "level").From("users")
+sb.Where(
+    sb.Equal("id", 1234),
+)
+fmt.Println(sb)
+
+ub := Update("users")
+ub.Set(
+    ub.Add("level", 10),
+)
+
+// Set the WHERE clause of UPDATE to the WHERE clause of SELECT.
+ub.WhereClause = sb.WhereClause
+fmt.Println(ub)
+
+// Output:
+// SELECT name, level FROM users WHERE id = ?
+// UPDATE users SET level = level + ? WHERE id = ?
+```
+
+The `WhereClause` is not thread-safe. Read samples for [WhereClause](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#WhereClause) to learn how to use it correctly.
+
 ### Build SQL for different systems
 
 SQL syntax and parameter marks vary in different systems. In this package, we introduce a concept called "flavor" to smooth out these difference.

args.go

@@ -141,22 +141,7 @@ func (args *Args) CompileWithFlavor(format string, flavor Flavor, initialValue .
 	}
 
 	query = buf.String()
-
-	if len(args.sqlNamedArgs) > 0 {
-		// Stabilize the sequence to make it easier to write test cases.
-		ints := make([]int, 0, len(args.sqlNamedArgs))
-
-		for _, p := range args.sqlNamedArgs {
-			ints = append(ints, p)
-		}
-
-		sort.Ints(ints)
-
-		for _, i := range ints {
-			values = append(values, args.args[i])
-		}
-	}
-
+	values = args.mergeSQLNamedArgs(values)
 	return
 }
 
@@ -253,8 +238,71 @@ func (args *Args) compileArg(buf *stringBuilder, flavor Flavor, values []interfa
 			panic(fmt.Errorf("Args.CompileWithFlavor: invalid flavor %v (%v)", flavor, int(flavor)))
 		}
 
-		values = append(values, arg)
+		namedValues := parseNamedArgs(values)
+
+		if n := len(namedValues); n == 0 {
+			values = append(values, arg)
+		} else {
+			index := len(values) - n
+			values = append(values[:index+1], namedValues...)
+			values[index] = arg
+		}
+	}
+
+	return values
+}
+
+func (args *Args) mergeSQLNamedArgs(values []interface{}) []interface{} {
+	if len(args.sqlNamedArgs) == 0 {
+		return values
+	}
+
+	namedValues := parseNamedArgs(values)
+	existingNames := make(map[string]struct{}, len(namedValues))
+
+	for _, v := range namedValues {
+		if a, ok := v.(sql.NamedArg); ok {
+			existingNames[a.Name] = struct{}{}
+		}
+	}
+
+	// Stabilize the sequence to make it easier to write test cases.
+	ints := make([]int, 0, len(args.sqlNamedArgs))
+
+	for n, p := range args.sqlNamedArgs {
+		if _, ok := existingNames[n]; ok {
+			continue
+		}
+
+		ints = append(ints, p)
+	}
+
+	sort.Ints(ints)
+
+	for _, i := range ints {
+		values = append(values, args.args[i])
 	}
 
 	return values
 }
+
+func parseNamedArgs(initialValue []interface{}) (namedValues []interface{}) {
+	if len(initialValue) == 0 {
+		return nil
+	}
+
+	// sql.NamedArgs must be placed at the end of the initial value.
+	i := len(initialValue)
+
+	for ; i > 0; i-- {
+		switch initialValue[i-1].(type) {
+		case sql.NamedArg:
+			continue
+		}
+
+		break
+	}
+
+	namedValues = initialValue[i:]
+	return
+}

cond.go

@@ -3,15 +3,18 @@
 
 package sqlbuilder
 
-import (
-	"strings"
-)
-
 // Cond provides several helper methods to build conditions.
 type Cond struct {
 	Args *Args
 }
 
+// NewCond returns a new Cond.
+func NewCond() *Cond {
+	return &Cond{
+		Args: &Args{},
+	}
+}
+
 // Equal represents "field = value".
 func (c *Cond) Equal(field string, value interface{}) string {
 	buf := newStringBuilder()
@@ -137,7 +140,7 @@ func (c *Cond) In(field string, value ...interface{}) string {
 	buf := newStringBuilder()
 	buf.WriteString(Escape(field))
 	buf.WriteString(" IN (")
-	buf.WriteString(strings.Join(vs, ", "))
+	buf.WriteStrings(vs, ", ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -153,7 +156,7 @@ func (c *Cond) NotIn(field string, value ...interface{}) string {
 	buf := newStringBuilder()
 	buf.WriteString(Escape(field))
 	buf.WriteString(" NOT IN (")
-	buf.WriteString(strings.Join(vs, ", "))
+	buf.WriteStrings(vs, ", ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -218,7 +221,7 @@ func (c *Cond) NotBetween(field string, lower, upper interface{}) string {
 func (c *Cond) Or(orExpr ...string) string {
 	buf := newStringBuilder()
 	buf.WriteString("(")
-	buf.WriteString(strings.Join(orExpr, " OR "))
+	buf.WriteStrings(orExpr, " OR ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -227,7 +230,7 @@ func (c *Cond) Or(orExpr ...string) string {
 func (c *Cond) And(andExpr ...string) string {
 	buf := newStringBuilder()
 	buf.WriteString("(")
-	buf.WriteString(strings.Join(andExpr, " AND "))
+	buf.WriteStrings(andExpr, " AND ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -263,7 +266,7 @@ func (c *Cond) Any(field, op string, value ...interface{}) string {
 	buf.WriteString(" ")
 	buf.WriteString(op)
 	buf.WriteString(" ANY (")
-	buf.WriteString(strings.Join(vs, ", "))
+	buf.WriteStrings(vs, ", ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -281,7 +284,7 @@ func (c *Cond) All(field, op string, value ...interface{}) string {
 	buf.WriteString(" ")
 	buf.WriteString(op)
 	buf.WriteString(" ALL (")
-	buf.WriteString(strings.Join(vs, ", "))
+	buf.WriteStrings(vs, ", ")
 	buf.WriteString(")")
 	return buf.String()
 }
@@ -299,7 +302,7 @@ func (c *Cond) Some(field, op string, value ...interface{}) string {
 	buf.WriteString(" ")
 	buf.WriteString(op)
 	buf.WriteString(" SOME (")
-	buf.WriteString(strings.Join(vs, ", "))
+	buf.WriteStrings(vs, ", ")
 	buf.WriteString(")")
 	return buf.String()
 }

createtable.go

@@ -131,7 +131,7 @@ func (ctb *CreateTableBuilder) BuildWithFlavor(flavor Flavor, initialArg ...inte
 			defs = append(defs, strings.Join(def, " "))
 		}
 
-		buf.WriteString(strings.Join(defs, ", "))
+		buf.WriteStrings(defs, ", ")
 		buf.WriteRune(')')
 
 		ctb.injection.WriteTo(buf, createTableMarkerAfterDefine)

delete.go

@@ -5,7 +5,6 @@ package sqlbuilder
 
 import (
 	"strconv"
-	"strings"
 )
 
 const (
@@ -23,7 +22,11 @@ func NewDeleteBuilder() *DeleteBuilder {
 
 func newDeleteBuilder() *DeleteBuilder {
 	args := &Args{}
+	proxy := &whereClauseProxy{}
 	return &DeleteBuilder{
+		whereClauseProxy: proxy,
+		whereClauseExpr:  args.Add(proxy),
+
 		Cond: Cond{
 			Args: args,
 		},
@@ -35,10 +38,13 @@ func newDeleteBuilder() *DeleteBuilder {
 
 // DeleteBuilder is a builder to build DELETE.
 type DeleteBuilder struct {
+	*WhereClause
 	Cond
 
+	whereClauseProxy *whereClauseProxy
+	whereClauseExpr  string
+
 	table       string
-	whereExprs  []string
 	orderByCols []string
 	order       string
 	limit       int
@@ -65,11 +71,25 @@ func (db *DeleteBuilder) DeleteFrom(table string) *DeleteBuilder {
 
 // Where sets expressions of WHERE in DELETE.
 func (db *DeleteBuilder) Where(andExpr ...string) *DeleteBuilder {
-	db.whereExprs = append(db.whereExprs, andExpr...)
+	if db.WhereClause == nil {
+		db.WhereClause = NewWhereClause()
+	}
+
+	db.WhereClause.AddWhereExpr(db.args, andExpr...)
 	db.marker = deleteMarkerAfterWhere
 	return db
 }
 
+// AddWhereClause adds all clauses in the whereClause to SELECT.
+func (db *DeleteBuilder) AddWhereClause(whereClause *WhereClause) *DeleteBuilder {
+	if db.WhereClause == nil {
+		db.WhereClause = NewWhereClause()
+	}
+
+	db.WhereClause.AddWhereClause(whereClause)
+	return db
+}
+
 // OrderBy sets columns of ORDER BY in DELETE.
 func (db *DeleteBuilder) OrderBy(col ...string) *DeleteBuilder {
 	db.orderByCols = col
@@ -123,16 +143,19 @@ func (db *DeleteBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interface{
 
 	db.injection.WriteTo(buf, deleteMarkerAfterDeleteFrom)
 
-	if len(db.whereExprs) > 0 {
-		buf.WriteLeadingString("WHERE ")
-		buf.WriteString(strings.Join(db.whereExprs, " AND "))
+	if db.WhereClause != nil {
+		db.whereClauseProxy.WhereClause = db.WhereClause
+		defer func() {
+			db.whereClauseProxy.WhereClause = nil
+		}()
 
+		buf.WriteLeadingString(db.whereClauseExpr)
 		db.injection.WriteTo(buf, deleteMarkerAfterWhere)
 	}
 
 	if len(db.orderByCols) > 0 {
 		buf.WriteLeadingString("ORDER BY ")
-		buf.WriteString(strings.Join(db.orderByCols, ", "))
+		buf.WriteStrings(db.orderByCols, ", ")
 
 		if db.order != "" {
 			buf.WriteRune(' ')

injection.go

@@ -3,10 +3,6 @@
 
 package sqlbuilder
 
-import (
-	"strings"
-)
-
 // injection is a helper type to manage injected SQLs in all builders.
 type injection struct {
 	markerSQLs map[injectionMarker][]string
@@ -36,6 +32,6 @@ func (injection *injection) WriteTo(buf *stringBuilder, marker injectionMarker)
 		return
 	}
 
-	s := strings.Join(sqls, " ")
-	buf.WriteLeadingString(s)
+	buf.WriteLeadingString("")
+	buf.WriteStrings(sqls, " ")
 }

insert.go

@@ -147,7 +147,7 @@ func (ib *InsertBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interface{
 			ib.injection.WriteTo(buf, insertMarkerAfterInsertInto)
 			if len(ib.cols) > 0 {
 				buf.WriteLeadingString("(")
-				buf.WriteString(strings.Join(ib.cols, ", "))
+				buf.WriteStrings(ib.cols, ", ")
 				buf.WriteString(")")
 
 				ib.injection.WriteTo(buf, insertMarkerAfterCols)
@@ -156,7 +156,7 @@ func (ib *InsertBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interface{
 			buf.WriteLeadingString("VALUES ")
 			values := make([]string, 0, len(ib.values))
 			values = append(values, fmt.Sprintf("(%v)", strings.Join(v, ", ")))
-			buf.WriteString(strings.Join(values, ", "))
+			buf.WriteStrings(values, ", ")
 		}
 
 		buf.WriteString(" SELECT 1 from DUAL")
@@ -176,7 +176,7 @@ func (ib *InsertBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interface{
 
 	if len(ib.cols) > 0 {
 		buf.WriteLeadingString("(")
-		buf.WriteString(strings.Join(ib.cols, ", "))
+		buf.WriteStrings(ib.cols, ", ")
 		buf.WriteString(")")
 
 		ib.injection.WriteTo(buf, insertMarkerAfterCols)
@@ -198,7 +198,7 @@ func (ib *InsertBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interface{
 			values = append(values, fmt.Sprintf("(%v)", strings.Join(v, ", ")))
 		}
 
-		buf.WriteString(strings.Join(values, ", "))
+		buf.WriteStrings(values, ", ")
 	}
 
 	ib.injection.WriteTo(buf, insertMarkerAfterValues)