Update From & more tests (#35)

* add more test cases & replace some err in errors.New(...) style & add some built-in err types

* update From & related test cases

* add test cases & fix bug

* fix issues

* update readme

* replace postgres placeholder

* Update From & add more tests

* fix issues

* compatibility with sql.NamedArg & ref test case

* compatibility with sql.NamedArg & ref test case

* update bench test

* enhance placeholder: in case of sql.NamedArg in args

* enhance ToSQL: compatible with different sql drivers

Author: BetaCat0

builder.go

@@ -4,6 +4,11 @@
 
 package builder
 
+import (
+	sql2 "database/sql"
+	"fmt"
+)
+
 type optype byte
 
 const (
@@ -64,6 +69,31 @@ func Dialect(dialect string) *Builder {
 	return builder
 }
 
+// MySQL is shortcut of Dialect(MySQL)
+func MySQL() *Builder {
+	return Dialect(MYSQL)
+}
+
+// MsSQL is shortcut of Dialect(MsSQL)
+func MsSQL() *Builder {
+	return Dialect(MSSQL)
+}
+
+// Oracle is shortcut of Dialect(Oracle)
+func Oracle() *Builder {
+	return Dialect(ORACLE)
+}
+
+// Postgres is shortcut of Dialect(Postgres)
+func Postgres() *Builder {
+	return Dialect(POSTGRES)
+}
+
+// SQLite is shortcut of Dialect(SQLITE)
+func SQLite() *Builder {
+	return Dialect(SQLITE)
+}
+
 // Where sets where SQL
 func (b *Builder) Where(cond Cond) *Builder {
 	if b.cond.IsValid() {
@@ -142,7 +172,10 @@ func (b *Builder) Union(unionTp string, unionCond *Builder) *Builder {
 	}
 
 	if unionCond != nil {
-		unionCond.dialect = builder.dialect
+		if unionCond.dialect == "" && builder.dialect != "" {
+			unionCond.dialect = builder.dialect
+		}
+
 		builder.unions = append(builder.unions, union{unionTp, unionCond})
 	}
 
@@ -257,7 +290,40 @@ func (b *Builder) ToSQL() (string, []interface{}, error) {
 		return "", nil, err
 	}
 
-	return w.writer.String(), w.args, nil
+	// in case of sql.NamedArg in args
+	for e := range w.args {
+		if namedArg, ok := w.args[e].(sql2.NamedArg); ok {
+			w.args[e] = namedArg.Value
+		}
+	}
+
+	var sql = w.writer.String()
+	var err error
+
+	switch b.dialect {
+	case ORACLE, MSSQL:
+		// This is for compatibility with different sql drivers
+		for e := range w.args {
+			w.args[e] = sql2.Named(fmt.Sprintf("p%d", e+1), w.args[e])
+		}
+
+		var prefix string
+		if b.dialect == ORACLE {
+			prefix = ":p"
+		} else {
+			prefix = "@p"
+		}
+
+		if sql, err = ConvertPlaceholder(sql, prefix); err != nil {
+			return "", nil, err
+		}
+	case POSTGRES:
+		if sql, err = ConvertPlaceholder(sql, "$"); err != nil {
+			return "", nil, err
+		}
+	}
+
+	return sql, w.args, nil
 }
 
 // ToBoundSQL

builder_b_test.go

@@ -187,7 +187,7 @@ func randUpdateByCondition(rgc *randGenConf) *Builder {
 	b := Update(eqs).From("table1")
 
 	if rgc.allowCond && rand.Intn(1000) >= 500 {
-		b = b.Where(randCond(b.selects, 3))
+		b.Where(randCond(fields, 3))
 	}
 
 	return b

builder_select.go

@@ -53,6 +53,14 @@ func (b *Builder) selectWriteTo(w Writer) error {
 		if b.cond.IsValid() && len(b.tableName) <= 0 {
 			return ErrUnnamedDerivedTable
 		}
+		if b.subQuery.dialect != "" && b.dialect != b.subQuery.dialect {
+			return ErrInconsistentDialect
+		}
+
+		// dialect of sub-query will inherit from the main one (if not set up)
+		if b.dialect != "" && b.subQuery.dialect == "" {
+			b.subQuery.dialect = b.dialect
+		}
 
 		switch b.subQuery.optype {
 		case selectType, unionType:

builder_select_test.go

@@ -119,4 +119,24 @@ func TestBuilder_From(t *testing.T) {
 	sql, args, err = Select("c").From(Delete(Eq{"a": 1}).From("table1"), "table1").ToSQL()
 	assert.Error(t, err)
 	assert.EqualValues(t, ErrUnexpectedSubQuery, err)
+
+	// from a sub-query in different dialect
+	sql, args, err = MySQL().Select("sub.id").From(
+		Oracle().Select("id").From("table1").Where(Eq{"a": 1}), "sub").Where(Eq{"b": 1}).ToSQL()
+	assert.Error(t, err)
+	assert.EqualValues(t, ErrInconsistentDialect, err)
+
+	// from a sub-query (dialect set up)
+	sql, args, err = MySQL().Select("sub.id").From(
+		MySQL().Select("id").From("table1").Where(Eq{"a": 1}), "sub").Where(Eq{"b": 1}).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT sub.id FROM (SELECT id FROM table1 WHERE a=?) sub WHERE b=?", sql)
+	assert.EqualValues(t, []interface{}{1, 1}, args)
+
+	// from a sub-query (dialect not set up)
+	sql, args, err = MySQL().Select("sub.id").From(
+		Select("id").From("table1").Where(Eq{"a": 1}), "sub").Where(Eq{"b": 1}).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT sub.id FROM (SELECT id FROM table1 WHERE a=?) sub WHERE b=?", sql)
+	assert.EqualValues(t, []interface{}{1, 1}, args)
 }

builder_union.go

@@ -26,6 +26,10 @@ func (b *Builder) unionWriteTo(w Writer) error {
 				return err
 			}
 		} else {
+			if b.dialect != "" && b.dialect != current.dialect {
+				return ErrInconsistentDialect
+			}
+
 			if idx != 0 {
 				fmt.Fprint(w, fmt.Sprintf(" UNION %v ", strings.ToUpper(u.unionType)))
 			}

builder_union_test.go

@@ -21,6 +21,22 @@ func TestBuilder_Union(t *testing.T) {
 	assert.EqualValues(t, "(SELECT * FROM t1 WHERE status=?) UNION ALL (SELECT * FROM t2 WHERE status=?) UNION DISTINCT (SELECT * FROM t2 WHERE status=?) UNION  (SELECT * FROM t2 WHERE status=?)", sql)
 	assert.EqualValues(t, []interface{}{"1", "2", "3", "3"}, args)
 
+	// sub-query will inherit dialect from the main one
+	sql, args, err = MySQL().Select("*").From("t1").Where(Eq{"status": "1"}).
+		Union("all", Select("*").From("t2").Where(Eq{"status": "2"}).Limit(10)).
+		Union("", Select("*").From("t2").Where(Eq{"status": "3"})).
+		ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "(SELECT * FROM t1 WHERE status=?) UNION ALL (SELECT * FROM t2 WHERE status=? LIMIT 10) UNION  (SELECT * FROM t2 WHERE status=?)", sql)
+	assert.EqualValues(t, []interface{}{"1", "2", "3"}, args)
+
+	// will raise error
+	sql, args, err = MySQL().Select("*").From("t1").Where(Eq{"status": "1"}).
+		Union("all", Oracle().Select("*").From("t2").Where(Eq{"status": "2"}).Limit(10)).
+		ToSQL()
+	assert.Error(t, err)
+	assert.EqualValues(t, ErrInconsistentDialect, err)
+
 	// will raise error
 	sql, args, err = Select("*").From("table1").Where(Eq{"a": "1"}).
 		Union("all", Select("*").From("table2").Where(Eq{"a": "2"})).

error.go

@@ -35,4 +35,6 @@ var (
 	ErrInvalidLimitation = errors.New("Offset or limit is not correct")
 	// ErrUnnamedDerivedTable Every derived table must have its own alias
 	ErrUnnamedDerivedTable = errors.New("Every derived table must have its own alias")
+	// ErrInconsistentDialect Inconsistent dialect in same builder
+	ErrInconsistentDialect = errors.New("Inconsistent dialect in same builder")
 )

sql.go

@@ -5,6 +5,7 @@
 package builder
 
 import (
+	sql2 "database/sql"
 	"fmt"
 	"reflect"
 	"time"
@@ -105,10 +106,15 @@ func ConvertToBoundSQL(sql string, args []interface{}) (string, error) {
 				return "", ErrNeedMoreArguments
 			}
 
-			if noSQLQuoteNeeded(args[j]) {
-				_, err = fmt.Fprint(&buf, args[j])
+			arg := args[j]
+			if namedArg, ok := arg.(sql2.NamedArg); ok {
+				arg = namedArg.Value
+			}
+
+			if noSQLQuoteNeeded(arg) {
+				_, err = fmt.Fprint(&buf, arg)
 			} else {
-				_, err = fmt.Fprintf(&buf, "'%v'", args[j])
+				_, err = fmt.Fprintf(&buf, "'%v'", arg)
 			}
 			if err != nil {
 				return "", err
@@ -129,27 +135,22 @@ func ConvertPlaceholder(sql, prefix string) (string, error) {
 	var i, j, start int
 	for ; i < len(sql); i++ {
 		if sql[i] == '?' {
-			_, err := buf.WriteString(sql[start:i])
-			if err != nil {
-				return "", err
-			}
-			start = i + 1
-
-			_, err = buf.WriteString(prefix)
-			if err != nil {
+			if _, err := buf.WriteString(sql[start:i]); err != nil {
 				return "", err
 			}
 
+			start = i + 1
 			j = j + 1
-			_, err = buf.WriteString(fmt.Sprintf("%d", j))
-			if err != nil {
+
+			if _, err := buf.WriteString(fmt.Sprintf("%v%d", prefix, j)); err != nil {
 				return "", err
 			}
 		}
 	}
-	_, err := buf.WriteString(sql[start:])
-	if err != nil {
+
+	if _, err := buf.WriteString(sql[start:]); err != nil {
 		return "", err
 	}
+
 	return buf.String(), nil
 }

sql_test.go

@@ -5,6 +5,7 @@
 package builder
 
 import (
+	sql2 "database/sql"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -35,6 +36,10 @@ func TestBoundSQLConverter(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, placeholderBoundSQL, newSQL)
 
+	newSQL, err = ConvertToBoundSQL(placeholderConverterSQL, []interface{}{1, 2.1, sql2.Named("any", "3"), uint(4), "5", true})
+	assert.NoError(t, err)
+	assert.EqualValues(t, placeholderBoundSQL, newSQL)
+
 	newSQL, err = ConvertToBoundSQL(placeholderConverterSQL, []interface{}{1, 2.1, "3", 4, "5"})
 	assert.Error(t, err)
 	assert.EqualValues(t, ErrNeedMoreArguments, err)
@@ -162,3 +167,42 @@ func TestExecutableCheck(t *testing.T) {
 	err = f.executableCheck("SELECT * FROM table3")
 	assert.Error(t, err)
 }
+
+func TestToSQLInDifferentDialects(t *testing.T) {
+	sql, args, err := Postgres().Select().From("table1").Where(Eq{"a": "1"}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=$1 AND b<>$2", sql)
+	assert.EqualValues(t, []interface{}{"1", "100"}, args)
+
+	sql, args, err = MySQL().Select().From("table1").Where(Eq{"a": "1"}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=? AND b<>?", sql)
+	assert.EqualValues(t, []interface{}{"1", "100"}, args)
+
+	sql, args, err = MsSQL().Select().From("table1").Where(Eq{"a": "1"}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=@p1 AND b<>@p2", sql)
+	assert.EqualValues(t, []interface{}{sql2.Named("p1", "1"), sql2.Named("p2", "100")}, args)
+
+	// test sql.NamedArg in cond
+	sql, args, err = MsSQL().Select().From("table1").Where(Eq{"a": sql2.NamedArg{Name: "param", Value: "1"}}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=@p1 AND b<>@p2", sql)
+	assert.EqualValues(t, []interface{}{sql2.Named("p1", "1"), sql2.Named("p2", "100")}, args)
+
+	sql, args, err = Oracle().Select().From("table1").Where(Eq{"a": "1"}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=:p1 AND b<>:p2", sql)
+	assert.EqualValues(t, []interface{}{sql2.Named("p1", "1"), sql2.Named("p2", "100")}, args)
+
+	// test sql.NamedArg in cond
+	sql, args, err = Oracle().Select().From("table1").Where(Eq{"a": sql2.Named("a", "1")}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=:p1 AND b<>:p2", sql)
+	assert.EqualValues(t, []interface{}{sql2.Named("p1", "1"), sql2.Named("p2", "100")}, args)
+
+	sql, args, err = SQLite().Select().From("table1").Where(Eq{"a": "1"}.And(Neq{"b": "100"})).ToSQL()
+	assert.NoError(t, err)
+	assert.EqualValues(t, "SELECT * FROM table1 WHERE a=? AND b<>?", sql)
+	assert.EqualValues(t, []interface{}{"1", "100"}, args)
+}