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)
+}