From 03f97fb0bfae460735ee479daef7a9c8c9690108 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Tue, 25 Apr 2017 19:19:18 -0400 Subject: [PATCH 1/9] Blindly followed the linter. --- README.md | 4 +- case.go | 30 +++++++-------- case_test.go | 32 ++++++++-------- delete.go | 20 +++++----- delete_test.go | 20 +++++----- expr.go | 72 +++++++++++++++++------------------ expr_test.go | 97 ++++++++++++++++++++++++------------------------ insert.go | 23 ++++++------ insert_test.go | 28 +++++++------- part.go | 12 +++--- select.go | 30 +++++++-------- select_test.go | 50 ++++++++++++------------- squirrel.go | 30 +++++++-------- squirrel_test.go | 28 +++++++------- update.go | 30 +++++++-------- update_test.go | 22 +++++------ where.go | 6 +-- where_test.go | 16 ++++---- 18 files changed, 276 insertions(+), 274 deletions(-) diff --git a/README.md b/README.md index e0c4394c..0ceb3708 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ users := sq.Select("*").From("users").Join("emails USING (email_id)") active := users.Where(sq.Eq{"deleted_at": nil}) -sql, args, err := active.ToSql() +sql, args, err := active.ToSQL() sql == "SELECT * FROM users JOIN emails USING (email_id) WHERE deleted_at IS NULL" ``` @@ -39,7 +39,7 @@ sql == "SELECT * FROM users JOIN emails USING (email_id) WHERE deleted_at IS NUL sql, args, err := sq. Insert("users").Columns("name", "age"). Values("moe", 13).Values("larry", sq.Expr("? + 5", 12)). - ToSql() + ToSQL() sql == "INSERT INTO users (name,age) VALUES (?,?),(?,? + 5)" ``` diff --git a/case.go b/case.go index 2eb69dd5..88a970e4 100644 --- a/case.go +++ b/case.go @@ -19,15 +19,15 @@ type sqlizerBuffer struct { err error } -// WriteSql converts Sqlizer to SQL strings and writes it to buffer -func (b *sqlizerBuffer) WriteSql(item Sqlizer) { +// WriteSQL converts Sqlizer to SQL strings and writes it to buffer +func (b *sqlizerBuffer) WriteSQL(item Sqlizer) { if b.err != nil { return } var str string var args []interface{} - str, args, b.err = item.ToSql() + str, args, b.err = item.ToSQL() if b.err != nil { return @@ -38,7 +38,7 @@ func (b *sqlizerBuffer) WriteSql(item Sqlizer) { b.args = append(b.args, args...) } -func (b *sqlizerBuffer) ToSql() (string, []interface{}, error) { +func (b *sqlizerBuffer) ToSQL() (string, []interface{}, error) { return b.String(), b.args, b.err } @@ -59,8 +59,8 @@ type caseData struct { Else Sqlizer } -// ToSql implements Sqlizer -func (d *caseData) ToSql() (sqlStr string, args []interface{}, err error) { +// ToSQL implements Sqlizer +func (d *caseData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.WhenParts) == 0 { err = errors.New("case expression must contain at lease one WHEN clause") @@ -71,33 +71,33 @@ func (d *caseData) ToSql() (sqlStr string, args []interface{}, err error) { sql.WriteString("CASE ") if d.What != nil { - sql.WriteSql(d.What) + sql.WriteSQL(d.What) } for _, p := range d.WhenParts { sql.WriteString("WHEN ") - sql.WriteSql(p.when) + sql.WriteSQL(p.when) sql.WriteString("THEN ") - sql.WriteSql(p.then) + sql.WriteSQL(p.then) } if d.Else != nil { sql.WriteString("ELSE ") - sql.WriteSql(d.Else) + sql.WriteSQL(d.Else) } sql.WriteString("END") - return sql.ToSql() + return sql.ToSQL() } // CaseBuilder builds SQL CASE construct which could be used as parts of queries. type CaseBuilder builder.Builder -// ToSql builds the query into a SQL string and bound args. -func (b CaseBuilder) ToSql() (string, []interface{}, error) { +// ToSQL builds the query into a SQL string and bound args. +func (b CaseBuilder) ToSQL() (string, []interface{}, error) { data := builder.GetStruct(b).(caseData) - return data.ToSql() + return data.ToSQL() } // what sets optional value for CASE construct "CASE [value] ..." @@ -112,7 +112,7 @@ func (b CaseBuilder) When(when interface{}, then interface{}) CaseBuilder { return builder.Append(b, "WhenParts", newWhenPart(when, then)).(CaseBuilder) } -// What sets optional "ELSE ..." part for CASE construct +// Else sets optional "ELSE ..." part for CASE construct func (b CaseBuilder) Else(expr interface{}) CaseBuilder { return builder.Set(b, "Else", newPart(expr)).(CaseBuilder) } diff --git a/case_test.go b/case_test.go index 06ba420a..cb3c6d10 100644 --- a/case_test.go +++ b/case_test.go @@ -15,17 +15,17 @@ func TestCaseWithVal(t *testing.T) { qb := Select(). Column(caseStmt). From("table") - sql, args, err := qb.ToSql() + sql, args, err := qb.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT CASE number " + + expectedSQL := "SELECT CASE number " + "WHEN 1 THEN one " + "WHEN 2 THEN two " + "ELSE ? " + "END " + "FROM table" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{"big number"} assert.Equal(t, expectedArgs, args) @@ -38,15 +38,15 @@ func TestCaseWithComplexVal(t *testing.T) { qb := Select(). Column(Alias(caseStmt, "complexCase")). From("table") - sql, args, err := qb.ToSql() + sql, args, err := qb.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT (CASE ? > ? " + + expectedSQL := "SELECT (CASE ? > ? " + "WHEN true THEN 'T' " + "END) AS complexCase " + "FROM table" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{10, 5} assert.Equal(t, expectedArgs, args) @@ -58,17 +58,17 @@ func TestCaseWithNoVal(t *testing.T) { When(Expr("x > ?", 1), Expr("CONCAT('x is greater than ', ?)", 2)) qb := Select().Column(caseStmt).From("table") - sql, args, err := qb.ToSql() + sql, args, err := qb.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT CASE " + + expectedSQL := "SELECT CASE " + "WHEN x = ? THEN x is zero " + "WHEN x > ? THEN CONCAT('x is greater than ', ?) " + "END " + "FROM table" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0, 1, 2} assert.Equal(t, expectedArgs, args) @@ -80,17 +80,17 @@ func TestCaseWithExpr(t *testing.T) { Else("42") qb := Select().Column(caseStmt).From("table") - sql, args, err := qb.ToSql() + sql, args, err := qb.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT CASE x = ? " + + expectedSQL := "SELECT CASE x = ? " + "WHEN true THEN ? " + "ELSE 42 " + "END " + "FROM table" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{true, "it's true!"} assert.Equal(t, expectedArgs, args) @@ -109,16 +109,16 @@ func TestMultipleCase(t *testing.T) { Column(Alias(caseStmtExpr, "case_expr")). From("table") - sql, args, err := qb.ToSql() + sql, args, err := qb.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT " + + expectedSQL := "SELECT " + "(CASE x = ? WHEN true THEN ? ELSE 42 END) AS case_noval, " + "(CASE WHEN x = ? THEN 'x is zero' WHEN x > ? THEN CONCAT('x is greater than ', ?) END) AS case_expr " + "FROM table" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{ true, "it's true!", @@ -133,7 +133,7 @@ func TestCaseWithNoWhenClause(t *testing.T) { qb := Select().Column(caseStmt).From("table") - _, _, err := qb.ToSql() + _, _, err := qb.ToSQL() assert.Error(t, err) diff --git a/delete.go b/delete.go index 8aa4f1e6..8b0faa6b 100644 --- a/delete.go +++ b/delete.go @@ -4,8 +4,9 @@ import ( "bytes" "database/sql" "fmt" - "github.com/lann/builder" "strings" + + "github.com/lann/builder" ) type deleteData struct { @@ -22,12 +23,12 @@ type deleteData struct { func (d *deleteData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return ExecWith(d.RunWith, d) } -func (d *deleteData) ToSql() (sqlStr string, args []interface{}, err error) { +func (d *deleteData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.From) == 0 { err = fmt.Errorf("delete statements must specify a From table") return @@ -36,7 +37,7 @@ func (d *deleteData) ToSql() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSql(sql, " ", args) + args, _ = d.Prefixes.AppendToSQL(sql, " ", args) sql.WriteString(" ") } @@ -45,7 +46,7 @@ func (d *deleteData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSql(d.WhereParts, sql, " AND ", args) + args, err = appendToSQL(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -68,14 +69,13 @@ func (d *deleteData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSql(sql, " ", args) + args, _ = d.Suffixes.AppendToSQL(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) return } - // Builder // DeleteBuilder builds SQL DELETE statements. @@ -108,10 +108,10 @@ func (b DeleteBuilder) Exec() (sql.Result, error) { // SQL methods -// ToSql builds the query into a SQL string and bound args. -func (b DeleteBuilder) ToSql() (string, []interface{}, error) { +// ToSQL builds the query into a SQL string and bound args. +func (b DeleteBuilder) ToSQL() (string, []interface{}, error) { data := builder.GetStruct(b).(deleteData) - return data.ToSql() + return data.ToSQL() } // Prefix adds an expression to the beginning of the query diff --git a/delete_test.go b/delete_test.go index fcdcf49f..2d551fde 100644 --- a/delete_test.go +++ b/delete_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestDeleteBuilderToSql(t *testing.T) { +func TestDeleteBuilderToSQL(t *testing.T) { b := Delete(""). Prefix("WITH prefix AS ?", 0). From("a"). @@ -16,31 +16,31 @@ func TestDeleteBuilderToSql(t *testing.T) { Offset(3). Suffix("RETURNING ?", 4) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := + expectedSQL := "WITH prefix AS ? " + "DELETE FROM a WHERE b = ? ORDER BY c LIMIT 2 OFFSET 3 " + "RETURNING ?" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0, 1, 4} assert.Equal(t, expectedArgs, args) } -func TestDeleteBuilderToSqlErr(t *testing.T) { - _, _, err := Delete("").ToSql() +func TestDeleteBuilderToSQLErr(t *testing.T) { + _, _, err := Delete("").ToSQL() assert.Error(t, err) } func TestDeleteBuilderPlaceholders(t *testing.T) { b := Delete("test").Where("x = ? AND y = ?", 1, 2) - sql, _, _ := b.PlaceholderFormat(Question).ToSql() + sql, _, _ := b.PlaceholderFormat(Question).ToSQL() assert.Equal(t, "DELETE FROM test WHERE x = ? AND y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() assert.Equal(t, "DELETE FROM test WHERE x = $1 AND y = $2", sql) } @@ -48,10 +48,10 @@ func TestDeleteBuilderRunners(t *testing.T) { db := &DBStub{} b := Delete("test").Where("x = ?", 1).RunWith(db) - expectedSql := "DELETE FROM test WHERE x = ?" + expectedSQL := "DELETE FROM test WHERE x = ?" b.Exec() - assert.Equal(t, expectedSql, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSql) } func TestDeleteBuilderNoRunner(t *testing.T) { diff --git a/expr.go b/expr.go index a8749f10..51f1c6d2 100644 --- a/expr.go +++ b/expr.go @@ -21,13 +21,13 @@ func Expr(sql string, args ...interface{}) expr { return expr{sql: sql, args: args} } -func (e expr) ToSql() (sql string, args []interface{}, err error) { +func (e expr) ToSQL() (sql string, args []interface{}, err error) { return e.sql, e.args, nil } type exprs []expr -func (es exprs) AppendToSql(w io.Writer, sep string, args []interface{}) ([]interface{}, error) { +func (es exprs) AppendToSQL(w io.Writer, sep string, args []interface{}) ([]interface{}, error) { for i, e := range es { if i > 0 { _, err := io.WriteString(w, sep) @@ -58,8 +58,8 @@ func Alias(expr Sqlizer, alias string) aliasExpr { return aliasExpr{expr, alias} } -func (e aliasExpr) ToSql() (sql string, args []interface{}, err error) { - sql, args, err = e.expr.ToSql() +func (e aliasExpr) ToSQL() (sql string, args []interface{}, err error) { + sql, args, err = e.expr.ToSQL() if err == nil { sql = fmt.Sprintf("(%s) AS %s", sql, e.alias) } @@ -71,12 +71,12 @@ func (e aliasExpr) ToSql() (sql string, args []interface{}, err error) { // .Where(Eq{"id": 1}) type Eq map[string]interface{} -func (eq Eq) toSql(useNotOpr bool) (sql string, args []interface{}, err error) { +func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { var ( exprs []string - equalOpr string = "=" - inOpr string = "IN" - nullOpr string = "IS" + equalOpr = "=" + inOpr = "IN" + nullOpr = "IS" ) if useNotOpr { @@ -122,8 +122,8 @@ func (eq Eq) toSql(useNotOpr bool) (sql string, args []interface{}, err error) { return } -func (eq Eq) ToSql() (sql string, args []interface{}, err error) { - return eq.toSql(false) +func (eq Eq) ToSQL() (sql string, args []interface{}, err error) { + return eq.toSQL(false) } // NotEq is syntactic sugar for use with Where/Having/Set methods. @@ -131,8 +131,8 @@ func (eq Eq) ToSql() (sql string, args []interface{}, err error) { // .Where(NotEq{"id": 1}) == "id <> 1" type NotEq Eq -func (neq NotEq) ToSql() (sql string, args []interface{}, err error) { - return Eq(neq).toSql(true) +func (neq NotEq) ToSQL() (sql string, args []interface{}, err error) { + return Eq(neq).toSQL(true) } // Lt is syntactic sugar for use with Where/Having/Set methods. @@ -140,10 +140,10 @@ func (neq NotEq) ToSql() (sql string, args []interface{}, err error) { // .Where(Lt{"id": 1}) type Lt map[string]interface{} -func (lt Lt) toSql(opposite, orEq bool) (sql string, args []interface{}, err error) { +func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err error) { var ( exprs []string - opr string = "<" + opr = "<" ) if opposite { @@ -167,24 +167,24 @@ func (lt Lt) toSql(opposite, orEq bool) (sql string, args []interface{}, err err if val == nil { err = fmt.Errorf("cannot use null with less than or greater than operators") return - } else { - valVal := reflect.ValueOf(val) - if valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice { - err = fmt.Errorf("cannot use array or slice with less than or greater than operators") - return - } else { - expr = fmt.Sprintf("%s %s ?", key, opr) - args = append(args, val) - } } + + valVal := reflect.ValueOf(val) + if valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice { + err = fmt.Errorf("cannot use array or slice with less than or greater than operators") + return + } + + expr = fmt.Sprintf("%s %s ?", key, opr) + args = append(args, val) exprs = append(exprs, expr) } sql = strings.Join(exprs, " AND ") return } -func (lt Lt) ToSql() (sql string, args []interface{}, err error) { - return lt.toSql(false, false) +func (lt Lt) ToSQL() (sql string, args []interface{}, err error) { + return lt.toSQL(false, false) } // LtOrEq is syntactic sugar for use with Where/Having/Set methods. @@ -192,8 +192,8 @@ func (lt Lt) ToSql() (sql string, args []interface{}, err error) { // .Where(LtOrEq{"id": 1}) == "id <= 1" type LtOrEq Lt -func (ltOrEq LtOrEq) ToSql() (sql string, args []interface{}, err error) { - return Lt(ltOrEq).toSql(false, true) +func (ltOrEq LtOrEq) ToSQL() (sql string, args []interface{}, err error) { + return Lt(ltOrEq).toSQL(false, true) } // Gt is syntactic sugar for use with Where/Having/Set methods. @@ -201,8 +201,8 @@ func (ltOrEq LtOrEq) ToSql() (sql string, args []interface{}, err error) { // .Where(Gt{"id": 1}) == "id > 1" type Gt Lt -func (gt Gt) ToSql() (sql string, args []interface{}, err error) { - return Lt(gt).toSql(true, false) +func (gt Gt) ToSQL() (sql string, args []interface{}, err error) { + return Lt(gt).toSQL(true, false) } // GtOrEq is syntactic sugar for use with Where/Having/Set methods. @@ -210,8 +210,8 @@ func (gt Gt) ToSql() (sql string, args []interface{}, err error) { // .Where(GtOrEq{"id": 1}) == "id >= 1" type GtOrEq Lt -func (gtOrEq GtOrEq) ToSql() (sql string, args []interface{}, err error) { - return Lt(gtOrEq).toSql(true, true) +func (gtOrEq GtOrEq) ToSQL() (sql string, args []interface{}, err error) { + return Lt(gtOrEq).toSQL(true, true) } type conj []Sqlizer @@ -219,12 +219,12 @@ type conj []Sqlizer func (c conj) join(sep string) (sql string, args []interface{}, err error) { var sqlParts []string for _, sqlizer := range c { - partSql, partArgs, err := sqlizer.ToSql() + partSQL, partArgs, err := sqlizer.ToSQL() if err != nil { return "", nil, err } - if partSql != "" { - sqlParts = append(sqlParts, partSql) + if partSQL != "" { + sqlParts = append(sqlParts, partSQL) args = append(args, partArgs...) } } @@ -236,12 +236,12 @@ func (c conj) join(sep string) (sql string, args []interface{}, err error) { type And conj -func (a And) ToSql() (string, []interface{}, error) { +func (a And) ToSQL() (string, []interface{}, error) { return conj(a).join(" AND ") } type Or conj -func (o Or) ToSql() (string, []interface{}, error) { +func (o Or) ToSQL() (string, []interface{}, error) { return conj(o).join(" OR ") } diff --git a/expr_test.go b/expr_test.go index f8565f4b..853479db 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2,135 +2,136 @@ package squirrel import ( "database/sql" - "github.com/stretchr/testify/assert" "testing" + + "github.com/stretchr/testify/assert" ) -func TestEqToSql(t *testing.T) { +func TestEqToSQL(t *testing.T) { b := Eq{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id = ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id = ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestEqInToSql(t *testing.T) { +func TestEqInToSQL(t *testing.T) { b := Eq{"id": []int{1, 2, 3}} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id IN (?,?,?)" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id IN (?,?,?)" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1, 2, 3} assert.Equal(t, expectedArgs, args) } -func TestNotEqToSql(t *testing.T) { +func TestNotEqToSQL(t *testing.T) { b := NotEq{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id <> ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id <> ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestEqNotInToSql(t *testing.T) { +func TestEqNotInToSQL(t *testing.T) { b := NotEq{"id": []int{1, 2, 3}} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id NOT IN (?,?,?)" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id NOT IN (?,?,?)" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1, 2, 3} assert.Equal(t, expectedArgs, args) } -func TestEqInEmptyToSql(t *testing.T) { +func TestEqInEmptyToSQL(t *testing.T) { b := Eq{"id": []int{}} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id IN (NULL)" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id IN (NULL)" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{} assert.Equal(t, expectedArgs, args) } -func TestLtToSql(t *testing.T) { +func TestLtToSQL(t *testing.T) { b := Lt{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id < ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id < ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestLtOrEqToSql(t *testing.T) { +func TestLtOrEqToSQL(t *testing.T) { b := LtOrEq{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id <= ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id <= ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestGtToSql(t *testing.T) { +func TestGtToSQL(t *testing.T) { b := Gt{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id > ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id > ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestGtOrEqToSql(t *testing.T) { +func TestGtOrEqToSQL(t *testing.T) { b := GtOrEq{"id": 1} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "id >= ?" - assert.Equal(t, expectedSql, sql) + expectedSQL := "id >= ?" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestExprNilToSql(t *testing.T) { +func TestExprNilToSQL(t *testing.T) { var b Sqlizer b = NotEq{"name": nil} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) assert.Empty(t, args) - expectedSql := "name IS NOT NULL" - assert.Equal(t, expectedSql, sql) + expectedSQL := "name IS NOT NULL" + assert.Equal(t, expectedSQL, sql) b = Eq{"name": nil} - sql, args, err = b.ToSql() + sql, args, err = b.ToSQL() assert.NoError(t, err) assert.Empty(t, args) - expectedSql = "name IS NULL" - assert.Equal(t, expectedSql, sql) + expectedSQL = "name IS NULL" + assert.Equal(t, expectedSQL, sql) } func TestNullTypeString(t *testing.T) { @@ -138,7 +139,7 @@ func TestNullTypeString(t *testing.T) { var name sql.NullString b = Eq{"name": name} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) assert.Empty(t, args) @@ -146,7 +147,7 @@ func TestNullTypeString(t *testing.T) { name.Scan("Name") b = Eq{"name": name} - sql, args, err = b.ToSql() + sql, args, err = b.ToSQL() assert.NoError(t, err) assert.Equal(t, []interface{}{"Name"}, args) @@ -157,7 +158,7 @@ func TestNullTypeInt64(t *testing.T) { var userID sql.NullInt64 userID.Scan(nil) b := Eq{"user_id": userID} - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) assert.Empty(t, args) @@ -165,7 +166,7 @@ func TestNullTypeInt64(t *testing.T) { userID.Scan(int64(10)) b = Eq{"user_id": userID} - sql, args, err = b.ToSql() + sql, args, err = b.ToSQL() assert.NoError(t, err) assert.Equal(t, []interface{}{int64(10)}, args) diff --git a/insert.go b/insert.go index f08025f5..28d10532 100644 --- a/insert.go +++ b/insert.go @@ -4,8 +4,9 @@ import ( "bytes" "database/sql" "fmt" - "github.com/lann/builder" "strings" + + "github.com/lann/builder" ) type insertData struct { @@ -21,30 +22,30 @@ type insertData struct { func (d *insertData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return ExecWith(d.RunWith, d) } func (d *insertData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return QueryWith(d.RunWith, d) } func (d *insertData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: RunnerNotSet} + return &Row{err: ErrRunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: RunnerNotQueryRunner} + return &Row{err: ErrRunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *insertData) ToSql() (sqlStr string, args []interface{}, err error) { +func (d *insertData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Into) == 0 { err = fmt.Errorf("insert statements must specify a table") return @@ -57,7 +58,7 @@ func (d *insertData) ToSql() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSql(sql, " ", args) + args, _ = d.Prefixes.AppendToSQL(sql, " ", args) sql.WriteString(" ") } @@ -99,7 +100,7 @@ func (d *insertData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSql(sql, " ", args) + args, _ = d.Suffixes.AppendToSQL(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -155,10 +156,10 @@ func (b InsertBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSql builds the query into a SQL string and bound args. -func (b InsertBuilder) ToSql() (string, []interface{}, error) { +// ToSQL builds the query into a SQL string and bound args. +func (b InsertBuilder) ToSQL() (string, []interface{}, error) { data := builder.GetStruct(b).(insertData) - return data.ToSql() + return data.ToSQL() } // Prefix adds an expression to the beginning of the query diff --git a/insert_test.go b/insert_test.go index 8c19eff9..f001186f 100644 --- a/insert_test.go +++ b/insert_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestInsertBuilderToSql(t *testing.T) { +func TestInsertBuilderToSQL(t *testing.T) { b := Insert(""). Prefix("WITH prefix AS ?", 0). Into("a"). @@ -16,34 +16,34 @@ func TestInsertBuilderToSql(t *testing.T) { Values(3, Expr("? + 1", 4)). Suffix("RETURNING ?", 5) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := + expectedSQL := "WITH prefix AS ? " + "INSERT DELAYED IGNORE INTO a (b,c) VALUES (?,?),(?,? + 1) " + "RETURNING ?" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0, 1, 2, 3, 4, 5} assert.Equal(t, expectedArgs, args) } -func TestInsertBuilderToSqlErr(t *testing.T) { - _, _, err := Insert("").Values(1).ToSql() +func TestInsertBuilderToSQLErr(t *testing.T) { + _, _, err := Insert("").Values(1).ToSQL() assert.Error(t, err) - _, _, err = Insert("x").ToSql() + _, _, err = Insert("x").ToSQL() assert.Error(t, err) } func TestInsertBuilderPlaceholders(t *testing.T) { b := Insert("test").Values(1, 2) - sql, _, _ := b.PlaceholderFormat(Question).ToSql() + sql, _, _ := b.PlaceholderFormat(Question).ToSQL() assert.Equal(t, "INSERT INTO test VALUES (?,?)", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() assert.Equal(t, "INSERT INTO test VALUES ($1,$2)", sql) } @@ -51,10 +51,10 @@ func TestInsertBuilderRunners(t *testing.T) { db := &DBStub{} b := Insert("test").Values(1).RunWith(db) - expectedSql := "INSERT INTO test VALUES (?)" + expectedSQL := "INSERT INTO test VALUES (?)" b.Exec() - assert.Equal(t, expectedSql, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSql) } func TestInsertBuilderNoRunner(t *testing.T) { @@ -67,11 +67,11 @@ func TestInsertBuilderNoRunner(t *testing.T) { func TestInsertBuilderSetMap(t *testing.T) { b := Insert("table").SetMap(Eq{"field1": 1}) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "INSERT INTO table (field1) VALUES (?)" - assert.Equal(t, expectedSql, sql) + expectedSQL := "INSERT INTO table (field1) VALUES (?)" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) diff --git a/part.go b/part.go index 2926d031..1b6509ec 100644 --- a/part.go +++ b/part.go @@ -14,12 +14,12 @@ func newPart(pred interface{}, args ...interface{}) Sqlizer { return &part{pred, args} } -func (p part) ToSql() (sql string, args []interface{}, err error) { +func (p part) ToSQL() (sql string, args []interface{}, err error) { switch pred := p.pred.(type) { case nil: // no-op case Sqlizer: - sql, args, err = pred.ToSql() + sql, args, err = pred.ToSQL() case string: sql = pred args = p.args @@ -29,12 +29,12 @@ func (p part) ToSql() (sql string, args []interface{}, err error) { return } -func appendToSql(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ([]interface{}, error) { +func appendToSQL(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ([]interface{}, error) { for i, p := range parts { - partSql, partArgs, err := p.ToSql() + partSQL, partArgs, err := p.ToSQL() if err != nil { return nil, err - } else if len(partSql) == 0 { + } else if len(partSQL) == 0 { continue } @@ -45,7 +45,7 @@ func appendToSql(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ( } } - _, err = io.WriteString(w, partSql) + _, err = io.WriteString(w, partSQL) if err != nil { return nil, err } diff --git a/select.go b/select.go index 7dc09bc5..577c7d37 100644 --- a/select.go +++ b/select.go @@ -28,30 +28,30 @@ type selectData struct { func (d *selectData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return ExecWith(d.RunWith, d) } func (d *selectData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return QueryWith(d.RunWith, d) } func (d *selectData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: RunnerNotSet} + return &Row{err: ErrRunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: RunnerNotQueryRunner} + return &Row{err: ErrRunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { +func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Columns) == 0 { err = fmt.Errorf("select statements must have at least one result column") return @@ -60,7 +60,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSql(sql, " ", args) + args, _ = d.Prefixes.AppendToSQL(sql, " ", args) sql.WriteString(" ") } @@ -72,7 +72,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { } if len(d.Columns) > 0 { - args, err = appendToSql(d.Columns, sql, ", ", args) + args, err = appendToSQL(d.Columns, sql, ", ", args) if err != nil { return } @@ -80,7 +80,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if d.From != nil { sql.WriteString(" FROM ") - args, err = appendToSql([]Sqlizer{d.From}, sql, "", args) + args, err = appendToSQL([]Sqlizer{d.From}, sql, "", args) if err != nil { return } @@ -88,7 +88,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Joins) > 0 { sql.WriteString(" ") - args, err = appendToSql(d.Joins, sql, " ", args) + args, err = appendToSQL(d.Joins, sql, " ", args) if err != nil { return } @@ -96,7 +96,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSql(d.WhereParts, sql, " AND ", args) + args, err = appendToSQL(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -109,7 +109,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.HavingParts) > 0 { sql.WriteString(" HAVING ") - args, err = appendToSql(d.HavingParts, sql, " AND ", args) + args, err = appendToSQL(d.HavingParts, sql, " AND ", args) if err != nil { return } @@ -132,7 +132,7 @@ func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSql(sql, " ", args) + args, _ = d.Suffixes.AppendToSQL(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -188,10 +188,10 @@ func (b SelectBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSql builds the query into a SQL string and bound args. -func (b SelectBuilder) ToSql() (string, []interface{}, error) { +// ToSQL builds the query into a SQL string and bound args. +func (b SelectBuilder) ToSQL() (string, []interface{}, error) { data := builder.GetStruct(b).(selectData) - return data.ToSql() + return data.ToSQL() } // Prefix adds an expression to the beginning of the query diff --git a/select_test.go b/select_test.go index 6db70003..05bc3b57 100644 --- a/select_test.go +++ b/select_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestSelectBuilderToSql(t *testing.T) { +func TestSelectBuilderToSQL(t *testing.T) { subQ := Select("aa", "bb").From("dd") b := Select("a", "b"). Prefix("WITH prefix AS ?", 0). @@ -33,10 +33,10 @@ func TestSelectBuilderToSql(t *testing.T) { Offset(13). Suffix("FETCH FIRST ? ROWS ONLY", 14) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := + expectedSQL := "WITH prefix AS ? " + "SELECT DISTINCT a, b, c, IF(d IN (?,?,?), 1, 0) as stat_column, a > ?, " + "(b IN (?,?,?)) AS b_alias, " + @@ -46,7 +46,7 @@ func TestSelectBuilderToSql(t *testing.T) { "WHERE f = ? AND g = ? AND h = ? AND i IN (?,?,?) AND (j = ? OR (k = ? AND true)) " + "GROUP BY l HAVING m = n ORDER BY o ASC, p DESC LIMIT 12 OFFSET 13 " + "FETCH FIRST ? ROWS ONLY" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0, 1, 2, 3, 100, 101, 102, 103, 4, 5, 6, 7, 8, 9, 10, 11, 14} assert.Equal(t, expectedArgs, args) @@ -55,28 +55,28 @@ func TestSelectBuilderToSql(t *testing.T) { func TestSelectBuilderFromSelect(t *testing.T) { subQ := Select("c").From("d").Where(Eq{"i": 0}) b := Select("a", "b").FromSelect(subQ, "subq") - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := "SELECT a, b FROM (SELECT c FROM d WHERE i = ?) AS subq" - assert.Equal(t, expectedSql, sql) + expectedSQL := "SELECT a, b FROM (SELECT c FROM d WHERE i = ?) AS subq" + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0} assert.Equal(t, expectedArgs, args) } -func TestSelectBuilderToSqlErr(t *testing.T) { - _, _, err := Select().From("x").ToSql() +func TestSelectBuilderToSQLErr(t *testing.T) { + _, _, err := Select().From("x").ToSQL() assert.Error(t, err) } func TestSelectBuilderPlaceholders(t *testing.T) { b := Select("test").Where("x = ? AND y = ?") - sql, _, _ := b.PlaceholderFormat(Question).ToSql() + sql, _, _ := b.PlaceholderFormat(Question).ToSQL() assert.Equal(t, "SELECT test WHERE x = ? AND y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() assert.Equal(t, "SELECT test WHERE x = $1 AND y = $2", sql) } @@ -84,16 +84,16 @@ func TestSelectBuilderRunners(t *testing.T) { db := &DBStub{} b := Select("test").RunWith(db) - expectedSql := "SELECT test" + expectedSQL := "SELECT test" b.Exec() - assert.Equal(t, expectedSql, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSql) b.Query() - assert.Equal(t, expectedSql, db.LastQuerySql) + assert.Equal(t, expectedSQL, db.LastQuerySql) b.QueryRow() - assert.Equal(t, expectedSql, db.LastQueryRowSql) + assert.Equal(t, expectedSQL, db.LastQueryRowSql) err := b.Scan() assert.NoError(t, err) @@ -114,50 +114,50 @@ func TestSelectBuilderNoRunner(t *testing.T) { func TestSelectBuilderSimpleJoin(t *testing.T) { - expectedSql := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo" + expectedSQL := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo" expectedArgs := []interface{}(nil) b := Select("*").From("bar").Join("baz ON bar.foo = baz.foo") - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) assert.Equal(t, args, expectedArgs) } func TestSelectBuilderParamJoin(t *testing.T) { - expectedSql := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo AND baz.foo = ?" + expectedSQL := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo AND baz.foo = ?" expectedArgs := []interface{}{42} b := Select("*").From("bar").Join("baz ON bar.foo = baz.foo AND baz.foo = ?", 42) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) assert.Equal(t, args, expectedArgs) } func TestSelectBuilderNestedSelectJoin(t *testing.T) { - expectedSql := "SELECT * FROM bar JOIN ( SELECT * FROM baz WHERE foo = ? ) r ON bar.foo = r.foo" + expectedSQL := "SELECT * FROM bar JOIN ( SELECT * FROM baz WHERE foo = ? ) r ON bar.foo = r.foo" expectedArgs := []interface{}{42} nestedSelect := Select("*").From("baz").Where("foo = ?", 42) b := Select("*").From("bar").JoinClause(nestedSelect.Prefix("JOIN (").Suffix(") r ON bar.foo = r.foo")) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) assert.Equal(t, args, expectedArgs) } func TestSelectWithOptions(t *testing.T) { - sql, _, err := Select("*").From("foo").Distinct().Options("SQL_NO_CACHE").ToSql() + sql, _, err := Select("*").From("foo").Distinct().Options("SQL_NO_CACHE").ToSQL() assert.NoError(t, err) assert.Equal(t, "SELECT DISTINCT SQL_NO_CACHE * FROM foo", sql) diff --git a/squirrel.go b/squirrel.go index 89aaf3dc..076e16f9 100644 --- a/squirrel.go +++ b/squirrel.go @@ -12,12 +12,12 @@ import ( "github.com/lann/builder" ) -// Sqlizer is the interface that wraps the ToSql method. +// Sqlizer is the interface that wraps the ToSQL method. // -// ToSql returns a SQL representation of the Sqlizer, along with a slice of args +// ToSQL returns a SQL representation of the Sqlizer, along with a slice of args // as passed to e.g. database/sql.Exec. It can also return an error. type Sqlizer interface { - ToSql() (string, []interface{}, error) + ToSQL() (string, []interface{}, error) } // Execer is the interface that wraps the Exec method. @@ -84,15 +84,15 @@ func setRunWith(b interface{}, baseRunner BaseRunner) interface{} { return builder.Set(b, "RunWith", runner) } -// RunnerNotSet is returned by methods that need a Runner if it isn't set. -var RunnerNotSet = fmt.Errorf("cannot run; no Runner set (RunWith)") +// ErrRunnerNotSet is returned by methods that need a Runner if it isn't set. +var ErrRunnerNotSet = fmt.Errorf("cannot run; no Runner set (RunWith)") -// RunnerNotQueryRunner is returned by QueryRow if the RunWith value doesn't implement QueryRower. -var RunnerNotQueryRunner = fmt.Errorf("cannot QueryRow; Runner is not a QueryRower") +// ErrRunnerNotQueryRunner is returned by QueryRow if the RunWith value doesn't implement QueryRower. +var ErrRunnerNotQueryRunner = fmt.Errorf("cannot QueryRow; Runner is not a QueryRower") // ExecWith Execs the SQL returned by s with db. func ExecWith(db Execer, s Sqlizer) (res sql.Result, err error) { - query, args, err := s.ToSql() + query, args, err := s.ToSQL() if err != nil { return } @@ -101,7 +101,7 @@ func ExecWith(db Execer, s Sqlizer) (res sql.Result, err error) { // QueryWith Querys the SQL returned by s with db. func QueryWith(db Queryer, s Sqlizer) (rows *sql.Rows, err error) { - query, args, err := s.ToSql() + query, args, err := s.ToSQL() if err != nil { return } @@ -110,23 +110,23 @@ func QueryWith(db Queryer, s Sqlizer) (rows *sql.Rows, err error) { // QueryRowWith QueryRows the SQL returned by s with db. func QueryRowWith(db QueryRower, s Sqlizer) RowScanner { - query, args, err := s.ToSql() + query, args, err := s.ToSQL() return &Row{RowScanner: db.QueryRow(query, args...), err: err} } -// DebugSqlizer calls ToSql on s and shows the approximate SQL to be executed +// DebugSqlizer calls ToSQL on s and shows the approximate SQL to be executed // -// If ToSql returns an error, the result of this method will look like: -// "[ToSql error: %s]" or "[DebugSqlizer error: %s]" +// If ToSQL returns an error, the result of this method will look like: +// "[ToSQL error: %s]" or "[DebugSqlizer error: %s]" // // IMPORTANT: As its name suggests, this function should only be used for // debugging. While the string result *might* be valid SQL, this function does // not try very hard to ensure it. Additionally, executing the output of this // function with any untrusted user input is certainly insecure. func DebugSqlizer(s Sqlizer) string { - sql, args, err := s.ToSql() + sql, args, err := s.ToSQL() if err != nil { - return fmt.Sprintf("[ToSql error: %s]", err) + return fmt.Sprintf("[ToSQL error: %s]", err) } // TODO: dedupe this with placeholder.go diff --git a/squirrel_test.go b/squirrel_test.go index a928fa65..fe64743b 100644 --- a/squirrel_test.go +++ b/squirrel_test.go @@ -12,41 +12,41 @@ import ( type DBStub struct { err error - LastPrepareSql string + LastPrepareSQL string PrepareCount int - LastExecSql string + LastExecSQL string LastExecArgs []interface{} - LastQuerySql string + LastQuerySQL string LastQueryArgs []interface{} - LastQueryRowSql string + LastQueryRowSQL string LastQueryRowArgs []interface{} } -var StubError = fmt.Errorf("this is a stub; this is only a stub") +var ErrStubError = fmt.Errorf("this is a stub; this is only a stub") func (s *DBStub) Prepare(query string) (*sql.Stmt, error) { - s.LastPrepareSql = query + s.LastPrepareSQL = query s.PrepareCount++ return nil, nil } func (s *DBStub) Exec(query string, args ...interface{}) (sql.Result, error) { - s.LastExecSql = query + s.LastExecSQL = query s.LastExecArgs = args return nil, nil } func (s *DBStub) Query(query string, args ...interface{}) (*sql.Rows, error) { - s.LastQuerySql = query + s.LastQuerySQL = query s.LastQueryArgs = args return nil, nil } func (s *DBStub) QueryRow(query string, args ...interface{}) RowScanner { - s.LastQueryRowSql = query + s.LastQueryRowSQL = query s.LastQueryRowArgs = args return &Row{RowScanner: &RowStub{}} } @@ -57,22 +57,22 @@ var sqlStr = "SELECT test" func TestExecWith(t *testing.T) { db := &DBStub{} ExecWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastExecSql) + assert.Equal(t, sqlStr, db.LastExecSQL) } func TestQueryWith(t *testing.T) { db := &DBStub{} QueryWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastQuerySql) + assert.Equal(t, sqlStr, db.LastQuerySQL) } func TestQueryRowWith(t *testing.T) { db := &DBStub{} QueryRowWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastQueryRowSql) + assert.Equal(t, sqlStr, db.LastQueryRowSQL) } -func TestWithToSqlErr(t *testing.T) { +func TestWithToSQLErr(t *testing.T) { db := &DBStub{} sqlizer := Select() @@ -100,5 +100,5 @@ func TestDebugSqlizerErrors(t *testing.T) { assert.True(t, strings.HasPrefix(errorMsg, "[DebugSqlizer error: ")) errorMsg = DebugSqlizer(Lt{"x": nil}) // Cannot use nil values with Lt - assert.True(t, strings.HasPrefix(errorMsg, "[ToSql error: ")) + assert.True(t, strings.HasPrefix(errorMsg, "[ToSQL error: ")) } diff --git a/update.go b/update.go index 682906bc..40bbb450 100644 --- a/update.go +++ b/update.go @@ -30,30 +30,30 @@ type setClause struct { func (d *updateData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return ExecWith(d.RunWith, d) } func (d *updateData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, RunnerNotSet + return nil, ErrRunnerNotSet } return QueryWith(d.RunWith, d) } func (d *updateData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: RunnerNotSet} + return &Row{err: ErrRunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: RunnerNotQueryRunner} + return &Row{err: ErrRunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *updateData) ToSql() (sqlStr string, args []interface{}, err error) { +func (d *updateData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Table) == 0 { err = fmt.Errorf("update statements must specify a table") return @@ -66,7 +66,7 @@ func (d *updateData) ToSql() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSql(sql, " ", args) + args, _ = d.Prefixes.AppendToSQL(sql, " ", args) sql.WriteString(" ") } @@ -76,22 +76,22 @@ func (d *updateData) ToSql() (sqlStr string, args []interface{}, err error) { sql.WriteString(" SET ") setSqls := make([]string, len(d.SetClauses)) for i, setClause := range d.SetClauses { - var valSql string + var valSQL string e, isExpr := setClause.value.(expr) if isExpr { - valSql = e.sql + valSQL = e.sql args = append(args, e.args...) } else { - valSql = "?" + valSQL = "?" args = append(args, setClause.value) } - setSqls[i] = fmt.Sprintf("%s = %s", setClause.column, valSql) + setSqls[i] = fmt.Sprintf("%s = %s", setClause.column, valSQL) } sql.WriteString(strings.Join(setSqls, ", ")) if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSql(d.WhereParts, sql, " AND ", args) + args, err = appendToSQL(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -114,7 +114,7 @@ func (d *updateData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSql(sql, " ", args) + args, _ = d.Suffixes.AppendToSQL(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -167,10 +167,10 @@ func (b UpdateBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSql builds the query into a SQL string and bound args. -func (b UpdateBuilder) ToSql() (string, []interface{}, error) { +// ToSQL builds the query into a SQL string and bound args. +func (b UpdateBuilder) ToSQL() (string, []interface{}, error) { data := builder.GetStruct(b).(updateData) - return data.ToSql() + return data.ToSQL() } // Prefix adds an expression to the beginning of the query diff --git a/update_test.go b/update_test.go index 13795c3d..0bf39b2d 100644 --- a/update_test.go +++ b/update_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestUpdateBuilderToSql(t *testing.T) { +func TestUpdateBuilderToSQL(t *testing.T) { b := Update(""). Prefix("WITH prefix AS ?", 0). Table("a"). @@ -18,35 +18,35 @@ func TestUpdateBuilderToSql(t *testing.T) { Offset(5). Suffix("RETURNING ?", 6) - sql, args, err := b.ToSql() + sql, args, err := b.ToSQL() assert.NoError(t, err) - expectedSql := + expectedSQL := "WITH prefix AS ? " + "UPDATE a SET b = ? + 1, c = ? WHERE d = ? " + "ORDER BY e LIMIT 4 OFFSET 5 " + "RETURNING ?" - assert.Equal(t, expectedSql, sql) + assert.Equal(t, expectedSQL, sql) expectedArgs := []interface{}{0, 1, 2, 3, 6} assert.Equal(t, expectedArgs, args) } -func TestUpdateBuilderToSqlErr(t *testing.T) { - _, _, err := Update("").Set("x", 1).ToSql() +func TestUpdateBuilderToSQLErr(t *testing.T) { + _, _, err := Update("").Set("x", 1).ToSQL() assert.Error(t, err) - _, _, err = Update("x").ToSql() + _, _, err = Update("x").ToSQL() assert.Error(t, err) } func TestUpdateBuilderPlaceholders(t *testing.T) { b := Update("test").SetMap(Eq{"x": 1, "y": 2}) - sql, _, _ := b.PlaceholderFormat(Question).ToSql() + sql, _, _ := b.PlaceholderFormat(Question).ToSQL() assert.Equal(t, "UPDATE test SET x = ?, y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() assert.Equal(t, "UPDATE test SET x = $1, y = $2", sql) } @@ -54,10 +54,10 @@ func TestUpdateBuilderRunners(t *testing.T) { db := &DBStub{} b := Update("test").Set("x", 1).RunWith(db) - expectedSql := "UPDATE test SET x = ?" + expectedSQL := "UPDATE test SET x = ?" b.Exec() - assert.Equal(t, expectedSql, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSQL) } func TestUpdateBuilderNoRunner(t *testing.T) { diff --git a/where.go b/where.go index 3a2d7b70..045cb549 100644 --- a/where.go +++ b/where.go @@ -10,14 +10,14 @@ func newWherePart(pred interface{}, args ...interface{}) Sqlizer { return &wherePart{pred: pred, args: args} } -func (p wherePart) ToSql() (sql string, args []interface{}, err error) { +func (p wherePart) ToSQL() (sql string, args []interface{}, err error) { switch pred := p.pred.(type) { case nil: // no-op case Sqlizer: - return pred.ToSql() + return pred.ToSQL() case map[string]interface{}: - return Eq(pred).ToSql() + return Eq(pred).ToSQL() case string: sql = pred args = p.args diff --git a/where_test.go b/where_test.go index d2109f17..692f5d5e 100644 --- a/where_test.go +++ b/where_test.go @@ -8,43 +8,43 @@ import ( "github.com/stretchr/testify/assert" ) -func TestWherePartsAppendToSql(t *testing.T) { +func TestWherePartsAppendToSQL(t *testing.T) { parts := []Sqlizer{ newWherePart("x = ?", 1), newWherePart(nil), newWherePart(Eq{"y": 2}), } sql := &bytes.Buffer{} - args, _ := appendToSql(parts, sql, " AND ", []interface{}{}) + args, _ := appendToSQL(parts, sql, " AND ", []interface{}{}) assert.Equal(t, "x = ? AND y = ?", sql.String()) assert.Equal(t, []interface{}{1, 2}, args) } -func TestWherePartsAppendToSqlErr(t *testing.T) { +func TestWherePartsAppendToSQLErr(t *testing.T) { parts := []Sqlizer{newWherePart(1)} - _, err := appendToSql(parts, &bytes.Buffer{}, "", []interface{}{}) + _, err := appendToSQL(parts, &bytes.Buffer{}, "", []interface{}{}) assert.Error(t, err) } func TestWherePartNil(t *testing.T) { - sql, _, _ := newWherePart(nil).ToSql() + sql, _, _ := newWherePart(nil).ToSQL() assert.Equal(t, "", sql) } func TestWherePartErr(t *testing.T) { - _, _, err := newWherePart(1).ToSql() + _, _, err := newWherePart(1).ToSQL() assert.Error(t, err) } func TestWherePartString(t *testing.T) { - sql, args, _ := newWherePart("x = ?", 1).ToSql() + sql, args, _ := newWherePart("x = ?", 1).ToSQL() assert.Equal(t, "x = ?", sql) assert.Equal(t, []interface{}{1}, args) } func TestWherePartMap(t *testing.T) { test := func(pred interface{}) { - sql, _, _ := newWherePart(pred).ToSql() + sql, _, _ := newWherePart(pred).ToSQL() expect := []string{"x = ? AND y = ?", "y = ? AND x = ?"} if sql != expect[0] && sql != expect[1] { t.Errorf("expected one of %#v, got %#v", expect, sql) From 79a452d8430666d7a68bddd7c848484002602291 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 11:20:55 -0400 Subject: [PATCH 2/9] Blindly followed the linter. Part 2. --- delete_test.go | 4 ++-- insert_test.go | 4 ++-- part.go | 2 +- select_test.go | 12 ++++++------ statement_test.go | 4 ++-- stmtcacher_test.go | 2 +- update_test.go | 2 +- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/delete_test.go b/delete_test.go index 2d551fde..eca1e21d 100644 --- a/delete_test.go +++ b/delete_test.go @@ -51,12 +51,12 @@ func TestDeleteBuilderRunners(t *testing.T) { expectedSQL := "DELETE FROM test WHERE x = ?" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSQL) } func TestDeleteBuilderNoRunner(t *testing.T) { b := Delete("test") _, err := b.Exec() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) } diff --git a/insert_test.go b/insert_test.go index f001186f..1b36ef90 100644 --- a/insert_test.go +++ b/insert_test.go @@ -54,14 +54,14 @@ func TestInsertBuilderRunners(t *testing.T) { expectedSQL := "INSERT INTO test VALUES (?)" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSQL) } func TestInsertBuilderNoRunner(t *testing.T) { b := Insert("test").Values(1) _, err := b.Exec() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) } func TestInsertBuilderSetMap(t *testing.T) { diff --git a/part.go b/part.go index 1b6509ec..e983a47b 100644 --- a/part.go +++ b/part.go @@ -39,7 +39,7 @@ func appendToSQL(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ( } if i > 0 { - _, err := io.WriteString(w, sep) + _, err = io.WriteString(w, sep) if err != nil { return nil, err } diff --git a/select_test.go b/select_test.go index 05bc3b57..0c529450 100644 --- a/select_test.go +++ b/select_test.go @@ -87,13 +87,13 @@ func TestSelectBuilderRunners(t *testing.T) { expectedSQL := "SELECT test" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSql) + assert.Equal(t, expectedSQL, db.LastExecSQL) b.Query() - assert.Equal(t, expectedSQL, db.LastQuerySql) + assert.Equal(t, expectedSQL, db.LastQuerySQL) b.QueryRow() - assert.Equal(t, expectedSQL, db.LastQueryRowSql) + assert.Equal(t, expectedSQL, db.LastQueryRowSQL) err := b.Scan() assert.NoError(t, err) @@ -103,13 +103,13 @@ func TestSelectBuilderNoRunner(t *testing.T) { b := Select("test") _, err := b.Exec() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) _, err = b.Query() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) err = b.Scan() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) } func TestSelectBuilderSimpleJoin(t *testing.T) { diff --git a/statement_test.go b/statement_test.go index 0353aa46..f25b4d5d 100644 --- a/statement_test.go +++ b/statement_test.go @@ -13,7 +13,7 @@ func TestStatementBuilder(t *testing.T) { sb := StatementBuilder.RunWith(db) sb.Select("test").Exec() - assert.Equal(t, "SELECT test", db.LastExecSql) + assert.Equal(t, "SELECT test", db.LastExecSQL) } func TestStatementBuilderPlaceholderFormat(t *testing.T) { @@ -21,7 +21,7 @@ func TestStatementBuilderPlaceholderFormat(t *testing.T) { sb := StatementBuilder.RunWith(db).PlaceholderFormat(Dollar) sb.Select("test").Where("x = ?").Exec() - assert.Equal(t, "SELECT test WHERE x = $1", db.LastExecSql) + assert.Equal(t, "SELECT test WHERE x = $1", db.LastExecSQL) } func TestRunWithDB(t *testing.T) { diff --git a/stmtcacher_test.go b/stmtcacher_test.go index 8198ef0c..3ec36036 100644 --- a/stmtcacher_test.go +++ b/stmtcacher_test.go @@ -12,7 +12,7 @@ func TestStmtCacherPrepare(t *testing.T) { query := "SELECT 1" sc.Prepare(query) - assert.Equal(t, query, db.LastPrepareSql) + assert.Equal(t, query, db.LastPrepareSQL) sc.Prepare(query) assert.Equal(t, 1, db.PrepareCount, "expected 1 Prepare, got %d", db.PrepareCount) diff --git a/update_test.go b/update_test.go index 0bf39b2d..fe353b97 100644 --- a/update_test.go +++ b/update_test.go @@ -64,5 +64,5 @@ func TestUpdateBuilderNoRunner(t *testing.T) { b := Update("test").Set("x", 1) _, err := b.Exec() - assert.Equal(t, RunnerNotSet, err) + assert.Equal(t, ErrRunnerNotSet, err) } From d6881cab5831547c36923d17c0fdcd18b442cc85 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 11:52:26 -0400 Subject: [PATCH 3/9] Blindly followed the linter. Part 3. --- expr.go | 8 ++++---- placeholder.go | 20 +++++++++++++++----- update.go | 2 +- 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/expr.go b/expr.go index 51f1c6d2..aba8c860 100644 --- a/expr.go +++ b/expr.go @@ -85,8 +85,10 @@ func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { nullOpr = "IS NOT" } + // Order the pairs. + for key, val := range eq { - expr := "" + var expr string switch v := val.(type) { case driver.Valuer: @@ -155,8 +157,6 @@ func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err err } for key, val := range lt { - expr := "" - switch v := val.(type) { case driver.Valuer: if val, err = v.Value(); err != nil { @@ -175,7 +175,7 @@ func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err err return } - expr = fmt.Sprintf("%s %s ?", key, opr) + expr := fmt.Sprintf("%s %s ?", key, opr) args = append(args, val) exprs = append(exprs, expr) } diff --git a/placeholder.go b/placeholder.go index d377788b..1fec4818 100644 --- a/placeholder.go +++ b/placeholder.go @@ -42,21 +42,31 @@ func (_ dollarFormat) ReplacePlaceholders(sql string) (string, error) { } if len(sql[p:]) > 1 && sql[p:p+2] == "??" { // escape ?? => ? - buf.WriteString(sql[:p]) - buf.WriteString("?") + if _, err := buf.WriteString(sql[:p]); err != nil { + return "", err + } + if _, err := buf.WriteString("?"); err != nil { + return "", err + } if len(sql[p:]) == 1 { break } sql = sql[p+2:] } else { i++ - buf.WriteString(sql[:p]) - fmt.Fprintf(buf, "$%d", i) + if _, err := buf.WriteString(sql[:p]); err != nil { + return "", err + } + if _, err := fmt.Fprintf(buf, "$%d", i); err != nil { + return "", err + } sql = sql[p+1:] } } - buf.WriteString(sql) + if _, err := buf.WriteString(sql); err != nil { + return "", err + } return buf.String(), nil } diff --git a/update.go b/update.go index 40bbb450..8dea7d29 100644 --- a/update.go +++ b/update.go @@ -198,7 +198,7 @@ func (b UpdateBuilder) SetMap(clauses map[string]interface{}) UpdateBuilder { } sort.Strings(keys) for _, key := range keys { - val, _ := clauses[key] + val := clauses[key] b = b.Set(key, val) } return b From 9647495534d5796d7024482fd57c9bdfdfbbdcd2 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 17:24:10 -0400 Subject: [PATCH 4/9] This orders the predicates in the resulting query -- allowing for more deterministic testing of queries that contain more than one predicate. They're always come out in the same order. --- expr.go | 25 ++++++++++++++++++++++--- expr_test.go | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 3 deletions(-) diff --git a/expr.go b/expr.go index aba8c860..6c0d8009 100644 --- a/expr.go +++ b/expr.go @@ -5,6 +5,7 @@ import ( "fmt" "io" "reflect" + "sort" "strings" ) @@ -66,6 +67,18 @@ func (e aliasExpr) ToSQL() (sql string, args []interface{}, err error) { return } +// GenerateOrderPredicateIndex provides a slice of keys useful for ordering predicates. +func GenerateOrderPredicateIndex(predicates map[string]interface{}) []string { + keys := make([]string, len(predicates)) + counter := 0 + for key := range predicates { + keys[counter] = key + counter++ + } + sort.Strings(keys) + return keys +} + // Eq is syntactic sugar for use with Where/Having/Set methods. // Ex: // .Where(Eq{"id": 1}) @@ -85,9 +98,11 @@ func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { nullOpr = "IS NOT" } - // Order the pairs. + predicateIndex := GenerateOrderPredicateIndex(eq) + + for _, key := range predicateIndex { + val := eq[key] - for key, val := range eq { var expr string switch v := val.(type) { @@ -156,7 +171,11 @@ func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err err opr = fmt.Sprintf("%s%s", opr, "=") } - for key, val := range lt { + predicateIndex := GenerateOrderPredicateIndex(lt) + + for _, key := range predicateIndex { + val := lt[key] + switch v := val.(type) { case driver.Valuer: if val, err = v.Value(); err != nil { diff --git a/expr_test.go b/expr_test.go index 853479db..aafc11aa 100644 --- a/expr_test.go +++ b/expr_test.go @@ -7,6 +7,41 @@ import ( "github.com/stretchr/testify/assert" ) +func TestGenerateOrderPredicateIndex(t *testing.T) { + output := []string{"one", "two"} + + type args struct { + predicates map[string]interface{} + } + + tests := []struct { + name string + args args + want []string + }{ + {"OrderPredTest1", args{Eq{"one": 1, "two": 2}}, output}, + {"OrderPredTest2", args{Eq{"two": 2, "one": 1}}, output}, + {"OrderPredTest3", args{Lt{"one": 1, "two": 2}}, output}, + {"OrderPredTest4", args{Lt{"two": 2, "one": 1}}, output}, + {"OrderPredTest5", args{Gt{"one": 1, "two": 2}}, output}, + {"OrderPredTest6", args{Gt{"two": 2, "one": 1}}, output}, + {"OrderPredTest7", args{GtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTest8", args{GtOrEq{"two": 2, "one": 1}}, output}, + {"OrderPredTest9", args{LtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTest10", args{LtOrEq{"two": 2, "one": 1}}, output}, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + got := GenerateOrderPredicateIndex(tt.args.predicates) + assert.Equal(t, tt.want, got) + }) + } +} + func TestEqToSQL(t *testing.T) { b := Eq{"id": 1} sql, args, err := b.ToSQL() From 9a659f7cdb36777c5eceae62404575a27f770ec0 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 17:41:34 -0400 Subject: [PATCH 5/9] Reversed the linter inspired changes. --- README.md | 4 +- case.go | 30 +++++++------- case_test.go | 32 +++++++-------- delete.go | 20 +++++----- delete_test.go | 22 +++++------ expr.go | 78 ++++++++++++++++++------------------- expr_test.go | 97 +++++++++++++++++++++++----------------------- insert.go | 23 ++++++----- insert_test.go | 30 +++++++------- part.go | 14 +++---- placeholder.go | 20 +++------- select.go | 30 +++++++------- select_test.go | 56 +++++++++++++------------- squirrel.go | 30 +++++++------- squirrel_test.go | 28 ++++++------- statement_test.go | 4 +- stmtcacher_test.go | 2 +- update.go | 32 +++++++-------- update_test.go | 24 ++++++------ where.go | 6 +-- where_test.go | 16 ++++---- 21 files changed, 293 insertions(+), 305 deletions(-) diff --git a/README.md b/README.md index 0ceb3708..e0c4394c 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ users := sq.Select("*").From("users").Join("emails USING (email_id)") active := users.Where(sq.Eq{"deleted_at": nil}) -sql, args, err := active.ToSQL() +sql, args, err := active.ToSql() sql == "SELECT * FROM users JOIN emails USING (email_id) WHERE deleted_at IS NULL" ``` @@ -39,7 +39,7 @@ sql == "SELECT * FROM users JOIN emails USING (email_id) WHERE deleted_at IS NUL sql, args, err := sq. Insert("users").Columns("name", "age"). Values("moe", 13).Values("larry", sq.Expr("? + 5", 12)). - ToSQL() + ToSql() sql == "INSERT INTO users (name,age) VALUES (?,?),(?,? + 5)" ``` diff --git a/case.go b/case.go index 88a970e4..2eb69dd5 100644 --- a/case.go +++ b/case.go @@ -19,15 +19,15 @@ type sqlizerBuffer struct { err error } -// WriteSQL converts Sqlizer to SQL strings and writes it to buffer -func (b *sqlizerBuffer) WriteSQL(item Sqlizer) { +// WriteSql converts Sqlizer to SQL strings and writes it to buffer +func (b *sqlizerBuffer) WriteSql(item Sqlizer) { if b.err != nil { return } var str string var args []interface{} - str, args, b.err = item.ToSQL() + str, args, b.err = item.ToSql() if b.err != nil { return @@ -38,7 +38,7 @@ func (b *sqlizerBuffer) WriteSQL(item Sqlizer) { b.args = append(b.args, args...) } -func (b *sqlizerBuffer) ToSQL() (string, []interface{}, error) { +func (b *sqlizerBuffer) ToSql() (string, []interface{}, error) { return b.String(), b.args, b.err } @@ -59,8 +59,8 @@ type caseData struct { Else Sqlizer } -// ToSQL implements Sqlizer -func (d *caseData) ToSQL() (sqlStr string, args []interface{}, err error) { +// ToSql implements Sqlizer +func (d *caseData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.WhenParts) == 0 { err = errors.New("case expression must contain at lease one WHEN clause") @@ -71,33 +71,33 @@ func (d *caseData) ToSQL() (sqlStr string, args []interface{}, err error) { sql.WriteString("CASE ") if d.What != nil { - sql.WriteSQL(d.What) + sql.WriteSql(d.What) } for _, p := range d.WhenParts { sql.WriteString("WHEN ") - sql.WriteSQL(p.when) + sql.WriteSql(p.when) sql.WriteString("THEN ") - sql.WriteSQL(p.then) + sql.WriteSql(p.then) } if d.Else != nil { sql.WriteString("ELSE ") - sql.WriteSQL(d.Else) + sql.WriteSql(d.Else) } sql.WriteString("END") - return sql.ToSQL() + return sql.ToSql() } // CaseBuilder builds SQL CASE construct which could be used as parts of queries. type CaseBuilder builder.Builder -// ToSQL builds the query into a SQL string and bound args. -func (b CaseBuilder) ToSQL() (string, []interface{}, error) { +// ToSql builds the query into a SQL string and bound args. +func (b CaseBuilder) ToSql() (string, []interface{}, error) { data := builder.GetStruct(b).(caseData) - return data.ToSQL() + return data.ToSql() } // what sets optional value for CASE construct "CASE [value] ..." @@ -112,7 +112,7 @@ func (b CaseBuilder) When(when interface{}, then interface{}) CaseBuilder { return builder.Append(b, "WhenParts", newWhenPart(when, then)).(CaseBuilder) } -// Else sets optional "ELSE ..." part for CASE construct +// What sets optional "ELSE ..." part for CASE construct func (b CaseBuilder) Else(expr interface{}) CaseBuilder { return builder.Set(b, "Else", newPart(expr)).(CaseBuilder) } diff --git a/case_test.go b/case_test.go index cb3c6d10..06ba420a 100644 --- a/case_test.go +++ b/case_test.go @@ -15,17 +15,17 @@ func TestCaseWithVal(t *testing.T) { qb := Select(). Column(caseStmt). From("table") - sql, args, err := qb.ToSQL() + sql, args, err := qb.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT CASE number " + + expectedSql := "SELECT CASE number " + "WHEN 1 THEN one " + "WHEN 2 THEN two " + "ELSE ? " + "END " + "FROM table" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{"big number"} assert.Equal(t, expectedArgs, args) @@ -38,15 +38,15 @@ func TestCaseWithComplexVal(t *testing.T) { qb := Select(). Column(Alias(caseStmt, "complexCase")). From("table") - sql, args, err := qb.ToSQL() + sql, args, err := qb.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT (CASE ? > ? " + + expectedSql := "SELECT (CASE ? > ? " + "WHEN true THEN 'T' " + "END) AS complexCase " + "FROM table" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{10, 5} assert.Equal(t, expectedArgs, args) @@ -58,17 +58,17 @@ func TestCaseWithNoVal(t *testing.T) { When(Expr("x > ?", 1), Expr("CONCAT('x is greater than ', ?)", 2)) qb := Select().Column(caseStmt).From("table") - sql, args, err := qb.ToSQL() + sql, args, err := qb.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT CASE " + + expectedSql := "SELECT CASE " + "WHEN x = ? THEN x is zero " + "WHEN x > ? THEN CONCAT('x is greater than ', ?) " + "END " + "FROM table" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0, 1, 2} assert.Equal(t, expectedArgs, args) @@ -80,17 +80,17 @@ func TestCaseWithExpr(t *testing.T) { Else("42") qb := Select().Column(caseStmt).From("table") - sql, args, err := qb.ToSQL() + sql, args, err := qb.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT CASE x = ? " + + expectedSql := "SELECT CASE x = ? " + "WHEN true THEN ? " + "ELSE 42 " + "END " + "FROM table" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{true, "it's true!"} assert.Equal(t, expectedArgs, args) @@ -109,16 +109,16 @@ func TestMultipleCase(t *testing.T) { Column(Alias(caseStmtExpr, "case_expr")). From("table") - sql, args, err := qb.ToSQL() + sql, args, err := qb.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT " + + expectedSql := "SELECT " + "(CASE x = ? WHEN true THEN ? ELSE 42 END) AS case_noval, " + "(CASE WHEN x = ? THEN 'x is zero' WHEN x > ? THEN CONCAT('x is greater than ', ?) END) AS case_expr " + "FROM table" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{ true, "it's true!", @@ -133,7 +133,7 @@ func TestCaseWithNoWhenClause(t *testing.T) { qb := Select().Column(caseStmt).From("table") - _, _, err := qb.ToSQL() + _, _, err := qb.ToSql() assert.Error(t, err) diff --git a/delete.go b/delete.go index 8b0faa6b..8aa4f1e6 100644 --- a/delete.go +++ b/delete.go @@ -4,9 +4,8 @@ import ( "bytes" "database/sql" "fmt" - "strings" - "github.com/lann/builder" + "strings" ) type deleteData struct { @@ -23,12 +22,12 @@ type deleteData struct { func (d *deleteData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return ExecWith(d.RunWith, d) } -func (d *deleteData) ToSQL() (sqlStr string, args []interface{}, err error) { +func (d *deleteData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.From) == 0 { err = fmt.Errorf("delete statements must specify a From table") return @@ -37,7 +36,7 @@ func (d *deleteData) ToSQL() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSQL(sql, " ", args) + args, _ = d.Prefixes.AppendToSql(sql, " ", args) sql.WriteString(" ") } @@ -46,7 +45,7 @@ func (d *deleteData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSQL(d.WhereParts, sql, " AND ", args) + args, err = appendToSql(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -69,13 +68,14 @@ func (d *deleteData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSQL(sql, " ", args) + args, _ = d.Suffixes.AppendToSql(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) return } + // Builder // DeleteBuilder builds SQL DELETE statements. @@ -108,10 +108,10 @@ func (b DeleteBuilder) Exec() (sql.Result, error) { // SQL methods -// ToSQL builds the query into a SQL string and bound args. -func (b DeleteBuilder) ToSQL() (string, []interface{}, error) { +// ToSql builds the query into a SQL string and bound args. +func (b DeleteBuilder) ToSql() (string, []interface{}, error) { data := builder.GetStruct(b).(deleteData) - return data.ToSQL() + return data.ToSql() } // Prefix adds an expression to the beginning of the query diff --git a/delete_test.go b/delete_test.go index eca1e21d..fcdcf49f 100644 --- a/delete_test.go +++ b/delete_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestDeleteBuilderToSQL(t *testing.T) { +func TestDeleteBuilderToSql(t *testing.T) { b := Delete(""). Prefix("WITH prefix AS ?", 0). From("a"). @@ -16,31 +16,31 @@ func TestDeleteBuilderToSQL(t *testing.T) { Offset(3). Suffix("RETURNING ?", 4) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := + expectedSql := "WITH prefix AS ? " + "DELETE FROM a WHERE b = ? ORDER BY c LIMIT 2 OFFSET 3 " + "RETURNING ?" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0, 1, 4} assert.Equal(t, expectedArgs, args) } -func TestDeleteBuilderToSQLErr(t *testing.T) { - _, _, err := Delete("").ToSQL() +func TestDeleteBuilderToSqlErr(t *testing.T) { + _, _, err := Delete("").ToSql() assert.Error(t, err) } func TestDeleteBuilderPlaceholders(t *testing.T) { b := Delete("test").Where("x = ? AND y = ?", 1, 2) - sql, _, _ := b.PlaceholderFormat(Question).ToSQL() + sql, _, _ := b.PlaceholderFormat(Question).ToSql() assert.Equal(t, "DELETE FROM test WHERE x = ? AND y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() assert.Equal(t, "DELETE FROM test WHERE x = $1 AND y = $2", sql) } @@ -48,15 +48,15 @@ func TestDeleteBuilderRunners(t *testing.T) { db := &DBStub{} b := Delete("test").Where("x = ?", 1).RunWith(db) - expectedSQL := "DELETE FROM test WHERE x = ?" + expectedSql := "DELETE FROM test WHERE x = ?" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSQL) + assert.Equal(t, expectedSql, db.LastExecSql) } func TestDeleteBuilderNoRunner(t *testing.T) { b := Delete("test") _, err := b.Exec() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) } diff --git a/expr.go b/expr.go index aba8c860..a8749f10 100644 --- a/expr.go +++ b/expr.go @@ -21,13 +21,13 @@ func Expr(sql string, args ...interface{}) expr { return expr{sql: sql, args: args} } -func (e expr) ToSQL() (sql string, args []interface{}, err error) { +func (e expr) ToSql() (sql string, args []interface{}, err error) { return e.sql, e.args, nil } type exprs []expr -func (es exprs) AppendToSQL(w io.Writer, sep string, args []interface{}) ([]interface{}, error) { +func (es exprs) AppendToSql(w io.Writer, sep string, args []interface{}) ([]interface{}, error) { for i, e := range es { if i > 0 { _, err := io.WriteString(w, sep) @@ -58,8 +58,8 @@ func Alias(expr Sqlizer, alias string) aliasExpr { return aliasExpr{expr, alias} } -func (e aliasExpr) ToSQL() (sql string, args []interface{}, err error) { - sql, args, err = e.expr.ToSQL() +func (e aliasExpr) ToSql() (sql string, args []interface{}, err error) { + sql, args, err = e.expr.ToSql() if err == nil { sql = fmt.Sprintf("(%s) AS %s", sql, e.alias) } @@ -71,12 +71,12 @@ func (e aliasExpr) ToSQL() (sql string, args []interface{}, err error) { // .Where(Eq{"id": 1}) type Eq map[string]interface{} -func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { +func (eq Eq) toSql(useNotOpr bool) (sql string, args []interface{}, err error) { var ( exprs []string - equalOpr = "=" - inOpr = "IN" - nullOpr = "IS" + equalOpr string = "=" + inOpr string = "IN" + nullOpr string = "IS" ) if useNotOpr { @@ -85,10 +85,8 @@ func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { nullOpr = "IS NOT" } - // Order the pairs. - for key, val := range eq { - var expr string + expr := "" switch v := val.(type) { case driver.Valuer: @@ -124,8 +122,8 @@ func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) { return } -func (eq Eq) ToSQL() (sql string, args []interface{}, err error) { - return eq.toSQL(false) +func (eq Eq) ToSql() (sql string, args []interface{}, err error) { + return eq.toSql(false) } // NotEq is syntactic sugar for use with Where/Having/Set methods. @@ -133,8 +131,8 @@ func (eq Eq) ToSQL() (sql string, args []interface{}, err error) { // .Where(NotEq{"id": 1}) == "id <> 1" type NotEq Eq -func (neq NotEq) ToSQL() (sql string, args []interface{}, err error) { - return Eq(neq).toSQL(true) +func (neq NotEq) ToSql() (sql string, args []interface{}, err error) { + return Eq(neq).toSql(true) } // Lt is syntactic sugar for use with Where/Having/Set methods. @@ -142,10 +140,10 @@ func (neq NotEq) ToSQL() (sql string, args []interface{}, err error) { // .Where(Lt{"id": 1}) type Lt map[string]interface{} -func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err error) { +func (lt Lt) toSql(opposite, orEq bool) (sql string, args []interface{}, err error) { var ( exprs []string - opr = "<" + opr string = "<" ) if opposite { @@ -157,6 +155,8 @@ func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err err } for key, val := range lt { + expr := "" + switch v := val.(type) { case driver.Valuer: if val, err = v.Value(); err != nil { @@ -167,24 +167,24 @@ func (lt Lt) toSQL(opposite, orEq bool) (sql string, args []interface{}, err err if val == nil { err = fmt.Errorf("cannot use null with less than or greater than operators") return + } else { + valVal := reflect.ValueOf(val) + if valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice { + err = fmt.Errorf("cannot use array or slice with less than or greater than operators") + return + } else { + expr = fmt.Sprintf("%s %s ?", key, opr) + args = append(args, val) + } } - - valVal := reflect.ValueOf(val) - if valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice { - err = fmt.Errorf("cannot use array or slice with less than or greater than operators") - return - } - - expr := fmt.Sprintf("%s %s ?", key, opr) - args = append(args, val) exprs = append(exprs, expr) } sql = strings.Join(exprs, " AND ") return } -func (lt Lt) ToSQL() (sql string, args []interface{}, err error) { - return lt.toSQL(false, false) +func (lt Lt) ToSql() (sql string, args []interface{}, err error) { + return lt.toSql(false, false) } // LtOrEq is syntactic sugar for use with Where/Having/Set methods. @@ -192,8 +192,8 @@ func (lt Lt) ToSQL() (sql string, args []interface{}, err error) { // .Where(LtOrEq{"id": 1}) == "id <= 1" type LtOrEq Lt -func (ltOrEq LtOrEq) ToSQL() (sql string, args []interface{}, err error) { - return Lt(ltOrEq).toSQL(false, true) +func (ltOrEq LtOrEq) ToSql() (sql string, args []interface{}, err error) { + return Lt(ltOrEq).toSql(false, true) } // Gt is syntactic sugar for use with Where/Having/Set methods. @@ -201,8 +201,8 @@ func (ltOrEq LtOrEq) ToSQL() (sql string, args []interface{}, err error) { // .Where(Gt{"id": 1}) == "id > 1" type Gt Lt -func (gt Gt) ToSQL() (sql string, args []interface{}, err error) { - return Lt(gt).toSQL(true, false) +func (gt Gt) ToSql() (sql string, args []interface{}, err error) { + return Lt(gt).toSql(true, false) } // GtOrEq is syntactic sugar for use with Where/Having/Set methods. @@ -210,8 +210,8 @@ func (gt Gt) ToSQL() (sql string, args []interface{}, err error) { // .Where(GtOrEq{"id": 1}) == "id >= 1" type GtOrEq Lt -func (gtOrEq GtOrEq) ToSQL() (sql string, args []interface{}, err error) { - return Lt(gtOrEq).toSQL(true, true) +func (gtOrEq GtOrEq) ToSql() (sql string, args []interface{}, err error) { + return Lt(gtOrEq).toSql(true, true) } type conj []Sqlizer @@ -219,12 +219,12 @@ type conj []Sqlizer func (c conj) join(sep string) (sql string, args []interface{}, err error) { var sqlParts []string for _, sqlizer := range c { - partSQL, partArgs, err := sqlizer.ToSQL() + partSql, partArgs, err := sqlizer.ToSql() if err != nil { return "", nil, err } - if partSQL != "" { - sqlParts = append(sqlParts, partSQL) + if partSql != "" { + sqlParts = append(sqlParts, partSql) args = append(args, partArgs...) } } @@ -236,12 +236,12 @@ func (c conj) join(sep string) (sql string, args []interface{}, err error) { type And conj -func (a And) ToSQL() (string, []interface{}, error) { +func (a And) ToSql() (string, []interface{}, error) { return conj(a).join(" AND ") } type Or conj -func (o Or) ToSQL() (string, []interface{}, error) { +func (o Or) ToSql() (string, []interface{}, error) { return conj(o).join(" OR ") } diff --git a/expr_test.go b/expr_test.go index 853479db..f8565f4b 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2,136 +2,135 @@ package squirrel import ( "database/sql" - "testing" - "github.com/stretchr/testify/assert" + "testing" ) -func TestEqToSQL(t *testing.T) { +func TestEqToSql(t *testing.T) { b := Eq{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id = ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id = ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestEqInToSQL(t *testing.T) { +func TestEqInToSql(t *testing.T) { b := Eq{"id": []int{1, 2, 3}} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id IN (?,?,?)" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id IN (?,?,?)" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1, 2, 3} assert.Equal(t, expectedArgs, args) } -func TestNotEqToSQL(t *testing.T) { +func TestNotEqToSql(t *testing.T) { b := NotEq{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id <> ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id <> ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestEqNotInToSQL(t *testing.T) { +func TestEqNotInToSql(t *testing.T) { b := NotEq{"id": []int{1, 2, 3}} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id NOT IN (?,?,?)" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id NOT IN (?,?,?)" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1, 2, 3} assert.Equal(t, expectedArgs, args) } -func TestEqInEmptyToSQL(t *testing.T) { +func TestEqInEmptyToSql(t *testing.T) { b := Eq{"id": []int{}} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id IN (NULL)" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id IN (NULL)" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{} assert.Equal(t, expectedArgs, args) } -func TestLtToSQL(t *testing.T) { +func TestLtToSql(t *testing.T) { b := Lt{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id < ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id < ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestLtOrEqToSQL(t *testing.T) { +func TestLtOrEqToSql(t *testing.T) { b := LtOrEq{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id <= ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id <= ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestGtToSQL(t *testing.T) { +func TestGtToSql(t *testing.T) { b := Gt{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id > ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id > ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestGtOrEqToSQL(t *testing.T) { +func TestGtOrEqToSql(t *testing.T) { b := GtOrEq{"id": 1} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "id >= ?" - assert.Equal(t, expectedSQL, sql) + expectedSql := "id >= ?" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) } -func TestExprNilToSQL(t *testing.T) { +func TestExprNilToSql(t *testing.T) { var b Sqlizer b = NotEq{"name": nil} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) assert.Empty(t, args) - expectedSQL := "name IS NOT NULL" - assert.Equal(t, expectedSQL, sql) + expectedSql := "name IS NOT NULL" + assert.Equal(t, expectedSql, sql) b = Eq{"name": nil} - sql, args, err = b.ToSQL() + sql, args, err = b.ToSql() assert.NoError(t, err) assert.Empty(t, args) - expectedSQL = "name IS NULL" - assert.Equal(t, expectedSQL, sql) + expectedSql = "name IS NULL" + assert.Equal(t, expectedSql, sql) } func TestNullTypeString(t *testing.T) { @@ -139,7 +138,7 @@ func TestNullTypeString(t *testing.T) { var name sql.NullString b = Eq{"name": name} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) assert.Empty(t, args) @@ -147,7 +146,7 @@ func TestNullTypeString(t *testing.T) { name.Scan("Name") b = Eq{"name": name} - sql, args, err = b.ToSQL() + sql, args, err = b.ToSql() assert.NoError(t, err) assert.Equal(t, []interface{}{"Name"}, args) @@ -158,7 +157,7 @@ func TestNullTypeInt64(t *testing.T) { var userID sql.NullInt64 userID.Scan(nil) b := Eq{"user_id": userID} - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) assert.Empty(t, args) @@ -166,7 +165,7 @@ func TestNullTypeInt64(t *testing.T) { userID.Scan(int64(10)) b = Eq{"user_id": userID} - sql, args, err = b.ToSQL() + sql, args, err = b.ToSql() assert.NoError(t, err) assert.Equal(t, []interface{}{int64(10)}, args) diff --git a/insert.go b/insert.go index 28d10532..f08025f5 100644 --- a/insert.go +++ b/insert.go @@ -4,9 +4,8 @@ import ( "bytes" "database/sql" "fmt" - "strings" - "github.com/lann/builder" + "strings" ) type insertData struct { @@ -22,30 +21,30 @@ type insertData struct { func (d *insertData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return ExecWith(d.RunWith, d) } func (d *insertData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return QueryWith(d.RunWith, d) } func (d *insertData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: ErrRunnerNotSet} + return &Row{err: RunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: ErrRunnerNotQueryRunner} + return &Row{err: RunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *insertData) ToSQL() (sqlStr string, args []interface{}, err error) { +func (d *insertData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Into) == 0 { err = fmt.Errorf("insert statements must specify a table") return @@ -58,7 +57,7 @@ func (d *insertData) ToSQL() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSQL(sql, " ", args) + args, _ = d.Prefixes.AppendToSql(sql, " ", args) sql.WriteString(" ") } @@ -100,7 +99,7 @@ func (d *insertData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSQL(sql, " ", args) + args, _ = d.Suffixes.AppendToSql(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -156,10 +155,10 @@ func (b InsertBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSQL builds the query into a SQL string and bound args. -func (b InsertBuilder) ToSQL() (string, []interface{}, error) { +// ToSql builds the query into a SQL string and bound args. +func (b InsertBuilder) ToSql() (string, []interface{}, error) { data := builder.GetStruct(b).(insertData) - return data.ToSQL() + return data.ToSql() } // Prefix adds an expression to the beginning of the query diff --git a/insert_test.go b/insert_test.go index 1b36ef90..8c19eff9 100644 --- a/insert_test.go +++ b/insert_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestInsertBuilderToSQL(t *testing.T) { +func TestInsertBuilderToSql(t *testing.T) { b := Insert(""). Prefix("WITH prefix AS ?", 0). Into("a"). @@ -16,34 +16,34 @@ func TestInsertBuilderToSQL(t *testing.T) { Values(3, Expr("? + 1", 4)). Suffix("RETURNING ?", 5) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := + expectedSql := "WITH prefix AS ? " + "INSERT DELAYED IGNORE INTO a (b,c) VALUES (?,?),(?,? + 1) " + "RETURNING ?" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0, 1, 2, 3, 4, 5} assert.Equal(t, expectedArgs, args) } -func TestInsertBuilderToSQLErr(t *testing.T) { - _, _, err := Insert("").Values(1).ToSQL() +func TestInsertBuilderToSqlErr(t *testing.T) { + _, _, err := Insert("").Values(1).ToSql() assert.Error(t, err) - _, _, err = Insert("x").ToSQL() + _, _, err = Insert("x").ToSql() assert.Error(t, err) } func TestInsertBuilderPlaceholders(t *testing.T) { b := Insert("test").Values(1, 2) - sql, _, _ := b.PlaceholderFormat(Question).ToSQL() + sql, _, _ := b.PlaceholderFormat(Question).ToSql() assert.Equal(t, "INSERT INTO test VALUES (?,?)", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() assert.Equal(t, "INSERT INTO test VALUES ($1,$2)", sql) } @@ -51,27 +51,27 @@ func TestInsertBuilderRunners(t *testing.T) { db := &DBStub{} b := Insert("test").Values(1).RunWith(db) - expectedSQL := "INSERT INTO test VALUES (?)" + expectedSql := "INSERT INTO test VALUES (?)" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSQL) + assert.Equal(t, expectedSql, db.LastExecSql) } func TestInsertBuilderNoRunner(t *testing.T) { b := Insert("test").Values(1) _, err := b.Exec() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) } func TestInsertBuilderSetMap(t *testing.T) { b := Insert("table").SetMap(Eq{"field1": 1}) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "INSERT INTO table (field1) VALUES (?)" - assert.Equal(t, expectedSQL, sql) + expectedSql := "INSERT INTO table (field1) VALUES (?)" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{1} assert.Equal(t, expectedArgs, args) diff --git a/part.go b/part.go index e983a47b..2926d031 100644 --- a/part.go +++ b/part.go @@ -14,12 +14,12 @@ func newPart(pred interface{}, args ...interface{}) Sqlizer { return &part{pred, args} } -func (p part) ToSQL() (sql string, args []interface{}, err error) { +func (p part) ToSql() (sql string, args []interface{}, err error) { switch pred := p.pred.(type) { case nil: // no-op case Sqlizer: - sql, args, err = pred.ToSQL() + sql, args, err = pred.ToSql() case string: sql = pred args = p.args @@ -29,23 +29,23 @@ func (p part) ToSQL() (sql string, args []interface{}, err error) { return } -func appendToSQL(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ([]interface{}, error) { +func appendToSql(parts []Sqlizer, w io.Writer, sep string, args []interface{}) ([]interface{}, error) { for i, p := range parts { - partSQL, partArgs, err := p.ToSQL() + partSql, partArgs, err := p.ToSql() if err != nil { return nil, err - } else if len(partSQL) == 0 { + } else if len(partSql) == 0 { continue } if i > 0 { - _, err = io.WriteString(w, sep) + _, err := io.WriteString(w, sep) if err != nil { return nil, err } } - _, err = io.WriteString(w, partSQL) + _, err = io.WriteString(w, partSql) if err != nil { return nil, err } diff --git a/placeholder.go b/placeholder.go index 1fec4818..d377788b 100644 --- a/placeholder.go +++ b/placeholder.go @@ -42,31 +42,21 @@ func (_ dollarFormat) ReplacePlaceholders(sql string) (string, error) { } if len(sql[p:]) > 1 && sql[p:p+2] == "??" { // escape ?? => ? - if _, err := buf.WriteString(sql[:p]); err != nil { - return "", err - } - if _, err := buf.WriteString("?"); err != nil { - return "", err - } + buf.WriteString(sql[:p]) + buf.WriteString("?") if len(sql[p:]) == 1 { break } sql = sql[p+2:] } else { i++ - if _, err := buf.WriteString(sql[:p]); err != nil { - return "", err - } - if _, err := fmt.Fprintf(buf, "$%d", i); err != nil { - return "", err - } + buf.WriteString(sql[:p]) + fmt.Fprintf(buf, "$%d", i) sql = sql[p+1:] } } - if _, err := buf.WriteString(sql); err != nil { - return "", err - } + buf.WriteString(sql) return buf.String(), nil } diff --git a/select.go b/select.go index 577c7d37..7dc09bc5 100644 --- a/select.go +++ b/select.go @@ -28,30 +28,30 @@ type selectData struct { func (d *selectData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return ExecWith(d.RunWith, d) } func (d *selectData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return QueryWith(d.RunWith, d) } func (d *selectData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: ErrRunnerNotSet} + return &Row{err: RunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: ErrRunnerNotQueryRunner} + return &Row{err: RunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { +func (d *selectData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Columns) == 0 { err = fmt.Errorf("select statements must have at least one result column") return @@ -60,7 +60,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSQL(sql, " ", args) + args, _ = d.Prefixes.AppendToSql(sql, " ", args) sql.WriteString(" ") } @@ -72,7 +72,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { } if len(d.Columns) > 0 { - args, err = appendToSQL(d.Columns, sql, ", ", args) + args, err = appendToSql(d.Columns, sql, ", ", args) if err != nil { return } @@ -80,7 +80,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if d.From != nil { sql.WriteString(" FROM ") - args, err = appendToSQL([]Sqlizer{d.From}, sql, "", args) + args, err = appendToSql([]Sqlizer{d.From}, sql, "", args) if err != nil { return } @@ -88,7 +88,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Joins) > 0 { sql.WriteString(" ") - args, err = appendToSQL(d.Joins, sql, " ", args) + args, err = appendToSql(d.Joins, sql, " ", args) if err != nil { return } @@ -96,7 +96,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSQL(d.WhereParts, sql, " AND ", args) + args, err = appendToSql(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -109,7 +109,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.HavingParts) > 0 { sql.WriteString(" HAVING ") - args, err = appendToSQL(d.HavingParts, sql, " AND ", args) + args, err = appendToSql(d.HavingParts, sql, " AND ", args) if err != nil { return } @@ -132,7 +132,7 @@ func (d *selectData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSQL(sql, " ", args) + args, _ = d.Suffixes.AppendToSql(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -188,10 +188,10 @@ func (b SelectBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSQL builds the query into a SQL string and bound args. -func (b SelectBuilder) ToSQL() (string, []interface{}, error) { +// ToSql builds the query into a SQL string and bound args. +func (b SelectBuilder) ToSql() (string, []interface{}, error) { data := builder.GetStruct(b).(selectData) - return data.ToSQL() + return data.ToSql() } // Prefix adds an expression to the beginning of the query diff --git a/select_test.go b/select_test.go index 0c529450..6db70003 100644 --- a/select_test.go +++ b/select_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestSelectBuilderToSQL(t *testing.T) { +func TestSelectBuilderToSql(t *testing.T) { subQ := Select("aa", "bb").From("dd") b := Select("a", "b"). Prefix("WITH prefix AS ?", 0). @@ -33,10 +33,10 @@ func TestSelectBuilderToSQL(t *testing.T) { Offset(13). Suffix("FETCH FIRST ? ROWS ONLY", 14) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := + expectedSql := "WITH prefix AS ? " + "SELECT DISTINCT a, b, c, IF(d IN (?,?,?), 1, 0) as stat_column, a > ?, " + "(b IN (?,?,?)) AS b_alias, " + @@ -46,7 +46,7 @@ func TestSelectBuilderToSQL(t *testing.T) { "WHERE f = ? AND g = ? AND h = ? AND i IN (?,?,?) AND (j = ? OR (k = ? AND true)) " + "GROUP BY l HAVING m = n ORDER BY o ASC, p DESC LIMIT 12 OFFSET 13 " + "FETCH FIRST ? ROWS ONLY" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0, 1, 2, 3, 100, 101, 102, 103, 4, 5, 6, 7, 8, 9, 10, 11, 14} assert.Equal(t, expectedArgs, args) @@ -55,28 +55,28 @@ func TestSelectBuilderToSQL(t *testing.T) { func TestSelectBuilderFromSelect(t *testing.T) { subQ := Select("c").From("d").Where(Eq{"i": 0}) b := Select("a", "b").FromSelect(subQ, "subq") - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := "SELECT a, b FROM (SELECT c FROM d WHERE i = ?) AS subq" - assert.Equal(t, expectedSQL, sql) + expectedSql := "SELECT a, b FROM (SELECT c FROM d WHERE i = ?) AS subq" + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0} assert.Equal(t, expectedArgs, args) } -func TestSelectBuilderToSQLErr(t *testing.T) { - _, _, err := Select().From("x").ToSQL() +func TestSelectBuilderToSqlErr(t *testing.T) { + _, _, err := Select().From("x").ToSql() assert.Error(t, err) } func TestSelectBuilderPlaceholders(t *testing.T) { b := Select("test").Where("x = ? AND y = ?") - sql, _, _ := b.PlaceholderFormat(Question).ToSQL() + sql, _, _ := b.PlaceholderFormat(Question).ToSql() assert.Equal(t, "SELECT test WHERE x = ? AND y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() assert.Equal(t, "SELECT test WHERE x = $1 AND y = $2", sql) } @@ -84,16 +84,16 @@ func TestSelectBuilderRunners(t *testing.T) { db := &DBStub{} b := Select("test").RunWith(db) - expectedSQL := "SELECT test" + expectedSql := "SELECT test" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSQL) + assert.Equal(t, expectedSql, db.LastExecSql) b.Query() - assert.Equal(t, expectedSQL, db.LastQuerySQL) + assert.Equal(t, expectedSql, db.LastQuerySql) b.QueryRow() - assert.Equal(t, expectedSQL, db.LastQueryRowSQL) + assert.Equal(t, expectedSql, db.LastQueryRowSql) err := b.Scan() assert.NoError(t, err) @@ -103,61 +103,61 @@ func TestSelectBuilderNoRunner(t *testing.T) { b := Select("test") _, err := b.Exec() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) _, err = b.Query() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) err = b.Scan() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) } func TestSelectBuilderSimpleJoin(t *testing.T) { - expectedSQL := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo" + expectedSql := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo" expectedArgs := []interface{}(nil) b := Select("*").From("bar").Join("baz ON bar.foo = baz.foo") - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) assert.Equal(t, args, expectedArgs) } func TestSelectBuilderParamJoin(t *testing.T) { - expectedSQL := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo AND baz.foo = ?" + expectedSql := "SELECT * FROM bar JOIN baz ON bar.foo = baz.foo AND baz.foo = ?" expectedArgs := []interface{}{42} b := Select("*").From("bar").Join("baz ON bar.foo = baz.foo AND baz.foo = ?", 42) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) assert.Equal(t, args, expectedArgs) } func TestSelectBuilderNestedSelectJoin(t *testing.T) { - expectedSQL := "SELECT * FROM bar JOIN ( SELECT * FROM baz WHERE foo = ? ) r ON bar.foo = r.foo" + expectedSql := "SELECT * FROM bar JOIN ( SELECT * FROM baz WHERE foo = ? ) r ON bar.foo = r.foo" expectedArgs := []interface{}{42} nestedSelect := Select("*").From("baz").Where("foo = ?", 42) b := Select("*").From("bar").JoinClause(nestedSelect.Prefix("JOIN (").Suffix(") r ON bar.foo = r.foo")) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) assert.Equal(t, args, expectedArgs) } func TestSelectWithOptions(t *testing.T) { - sql, _, err := Select("*").From("foo").Distinct().Options("SQL_NO_CACHE").ToSQL() + sql, _, err := Select("*").From("foo").Distinct().Options("SQL_NO_CACHE").ToSql() assert.NoError(t, err) assert.Equal(t, "SELECT DISTINCT SQL_NO_CACHE * FROM foo", sql) diff --git a/squirrel.go b/squirrel.go index 076e16f9..89aaf3dc 100644 --- a/squirrel.go +++ b/squirrel.go @@ -12,12 +12,12 @@ import ( "github.com/lann/builder" ) -// Sqlizer is the interface that wraps the ToSQL method. +// Sqlizer is the interface that wraps the ToSql method. // -// ToSQL returns a SQL representation of the Sqlizer, along with a slice of args +// ToSql returns a SQL representation of the Sqlizer, along with a slice of args // as passed to e.g. database/sql.Exec. It can also return an error. type Sqlizer interface { - ToSQL() (string, []interface{}, error) + ToSql() (string, []interface{}, error) } // Execer is the interface that wraps the Exec method. @@ -84,15 +84,15 @@ func setRunWith(b interface{}, baseRunner BaseRunner) interface{} { return builder.Set(b, "RunWith", runner) } -// ErrRunnerNotSet is returned by methods that need a Runner if it isn't set. -var ErrRunnerNotSet = fmt.Errorf("cannot run; no Runner set (RunWith)") +// RunnerNotSet is returned by methods that need a Runner if it isn't set. +var RunnerNotSet = fmt.Errorf("cannot run; no Runner set (RunWith)") -// ErrRunnerNotQueryRunner is returned by QueryRow if the RunWith value doesn't implement QueryRower. -var ErrRunnerNotQueryRunner = fmt.Errorf("cannot QueryRow; Runner is not a QueryRower") +// RunnerNotQueryRunner is returned by QueryRow if the RunWith value doesn't implement QueryRower. +var RunnerNotQueryRunner = fmt.Errorf("cannot QueryRow; Runner is not a QueryRower") // ExecWith Execs the SQL returned by s with db. func ExecWith(db Execer, s Sqlizer) (res sql.Result, err error) { - query, args, err := s.ToSQL() + query, args, err := s.ToSql() if err != nil { return } @@ -101,7 +101,7 @@ func ExecWith(db Execer, s Sqlizer) (res sql.Result, err error) { // QueryWith Querys the SQL returned by s with db. func QueryWith(db Queryer, s Sqlizer) (rows *sql.Rows, err error) { - query, args, err := s.ToSQL() + query, args, err := s.ToSql() if err != nil { return } @@ -110,23 +110,23 @@ func QueryWith(db Queryer, s Sqlizer) (rows *sql.Rows, err error) { // QueryRowWith QueryRows the SQL returned by s with db. func QueryRowWith(db QueryRower, s Sqlizer) RowScanner { - query, args, err := s.ToSQL() + query, args, err := s.ToSql() return &Row{RowScanner: db.QueryRow(query, args...), err: err} } -// DebugSqlizer calls ToSQL on s and shows the approximate SQL to be executed +// DebugSqlizer calls ToSql on s and shows the approximate SQL to be executed // -// If ToSQL returns an error, the result of this method will look like: -// "[ToSQL error: %s]" or "[DebugSqlizer error: %s]" +// If ToSql returns an error, the result of this method will look like: +// "[ToSql error: %s]" or "[DebugSqlizer error: %s]" // // IMPORTANT: As its name suggests, this function should only be used for // debugging. While the string result *might* be valid SQL, this function does // not try very hard to ensure it. Additionally, executing the output of this // function with any untrusted user input is certainly insecure. func DebugSqlizer(s Sqlizer) string { - sql, args, err := s.ToSQL() + sql, args, err := s.ToSql() if err != nil { - return fmt.Sprintf("[ToSQL error: %s]", err) + return fmt.Sprintf("[ToSql error: %s]", err) } // TODO: dedupe this with placeholder.go diff --git a/squirrel_test.go b/squirrel_test.go index fe64743b..a928fa65 100644 --- a/squirrel_test.go +++ b/squirrel_test.go @@ -12,41 +12,41 @@ import ( type DBStub struct { err error - LastPrepareSQL string + LastPrepareSql string PrepareCount int - LastExecSQL string + LastExecSql string LastExecArgs []interface{} - LastQuerySQL string + LastQuerySql string LastQueryArgs []interface{} - LastQueryRowSQL string + LastQueryRowSql string LastQueryRowArgs []interface{} } -var ErrStubError = fmt.Errorf("this is a stub; this is only a stub") +var StubError = fmt.Errorf("this is a stub; this is only a stub") func (s *DBStub) Prepare(query string) (*sql.Stmt, error) { - s.LastPrepareSQL = query + s.LastPrepareSql = query s.PrepareCount++ return nil, nil } func (s *DBStub) Exec(query string, args ...interface{}) (sql.Result, error) { - s.LastExecSQL = query + s.LastExecSql = query s.LastExecArgs = args return nil, nil } func (s *DBStub) Query(query string, args ...interface{}) (*sql.Rows, error) { - s.LastQuerySQL = query + s.LastQuerySql = query s.LastQueryArgs = args return nil, nil } func (s *DBStub) QueryRow(query string, args ...interface{}) RowScanner { - s.LastQueryRowSQL = query + s.LastQueryRowSql = query s.LastQueryRowArgs = args return &Row{RowScanner: &RowStub{}} } @@ -57,22 +57,22 @@ var sqlStr = "SELECT test" func TestExecWith(t *testing.T) { db := &DBStub{} ExecWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastExecSQL) + assert.Equal(t, sqlStr, db.LastExecSql) } func TestQueryWith(t *testing.T) { db := &DBStub{} QueryWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastQuerySQL) + assert.Equal(t, sqlStr, db.LastQuerySql) } func TestQueryRowWith(t *testing.T) { db := &DBStub{} QueryRowWith(db, sqlizer) - assert.Equal(t, sqlStr, db.LastQueryRowSQL) + assert.Equal(t, sqlStr, db.LastQueryRowSql) } -func TestWithToSQLErr(t *testing.T) { +func TestWithToSqlErr(t *testing.T) { db := &DBStub{} sqlizer := Select() @@ -100,5 +100,5 @@ func TestDebugSqlizerErrors(t *testing.T) { assert.True(t, strings.HasPrefix(errorMsg, "[DebugSqlizer error: ")) errorMsg = DebugSqlizer(Lt{"x": nil}) // Cannot use nil values with Lt - assert.True(t, strings.HasPrefix(errorMsg, "[ToSQL error: ")) + assert.True(t, strings.HasPrefix(errorMsg, "[ToSql error: ")) } diff --git a/statement_test.go b/statement_test.go index f25b4d5d..0353aa46 100644 --- a/statement_test.go +++ b/statement_test.go @@ -13,7 +13,7 @@ func TestStatementBuilder(t *testing.T) { sb := StatementBuilder.RunWith(db) sb.Select("test").Exec() - assert.Equal(t, "SELECT test", db.LastExecSQL) + assert.Equal(t, "SELECT test", db.LastExecSql) } func TestStatementBuilderPlaceholderFormat(t *testing.T) { @@ -21,7 +21,7 @@ func TestStatementBuilderPlaceholderFormat(t *testing.T) { sb := StatementBuilder.RunWith(db).PlaceholderFormat(Dollar) sb.Select("test").Where("x = ?").Exec() - assert.Equal(t, "SELECT test WHERE x = $1", db.LastExecSQL) + assert.Equal(t, "SELECT test WHERE x = $1", db.LastExecSql) } func TestRunWithDB(t *testing.T) { diff --git a/stmtcacher_test.go b/stmtcacher_test.go index 3ec36036..8198ef0c 100644 --- a/stmtcacher_test.go +++ b/stmtcacher_test.go @@ -12,7 +12,7 @@ func TestStmtCacherPrepare(t *testing.T) { query := "SELECT 1" sc.Prepare(query) - assert.Equal(t, query, db.LastPrepareSQL) + assert.Equal(t, query, db.LastPrepareSql) sc.Prepare(query) assert.Equal(t, 1, db.PrepareCount, "expected 1 Prepare, got %d", db.PrepareCount) diff --git a/update.go b/update.go index 8dea7d29..682906bc 100644 --- a/update.go +++ b/update.go @@ -30,30 +30,30 @@ type setClause struct { func (d *updateData) Exec() (sql.Result, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return ExecWith(d.RunWith, d) } func (d *updateData) Query() (*sql.Rows, error) { if d.RunWith == nil { - return nil, ErrRunnerNotSet + return nil, RunnerNotSet } return QueryWith(d.RunWith, d) } func (d *updateData) QueryRow() RowScanner { if d.RunWith == nil { - return &Row{err: ErrRunnerNotSet} + return &Row{err: RunnerNotSet} } queryRower, ok := d.RunWith.(QueryRower) if !ok { - return &Row{err: ErrRunnerNotQueryRunner} + return &Row{err: RunnerNotQueryRunner} } return QueryRowWith(queryRower, d) } -func (d *updateData) ToSQL() (sqlStr string, args []interface{}, err error) { +func (d *updateData) ToSql() (sqlStr string, args []interface{}, err error) { if len(d.Table) == 0 { err = fmt.Errorf("update statements must specify a table") return @@ -66,7 +66,7 @@ func (d *updateData) ToSQL() (sqlStr string, args []interface{}, err error) { sql := &bytes.Buffer{} if len(d.Prefixes) > 0 { - args, _ = d.Prefixes.AppendToSQL(sql, " ", args) + args, _ = d.Prefixes.AppendToSql(sql, " ", args) sql.WriteString(" ") } @@ -76,22 +76,22 @@ func (d *updateData) ToSQL() (sqlStr string, args []interface{}, err error) { sql.WriteString(" SET ") setSqls := make([]string, len(d.SetClauses)) for i, setClause := range d.SetClauses { - var valSQL string + var valSql string e, isExpr := setClause.value.(expr) if isExpr { - valSQL = e.sql + valSql = e.sql args = append(args, e.args...) } else { - valSQL = "?" + valSql = "?" args = append(args, setClause.value) } - setSqls[i] = fmt.Sprintf("%s = %s", setClause.column, valSQL) + setSqls[i] = fmt.Sprintf("%s = %s", setClause.column, valSql) } sql.WriteString(strings.Join(setSqls, ", ")) if len(d.WhereParts) > 0 { sql.WriteString(" WHERE ") - args, err = appendToSQL(d.WhereParts, sql, " AND ", args) + args, err = appendToSql(d.WhereParts, sql, " AND ", args) if err != nil { return } @@ -114,7 +114,7 @@ func (d *updateData) ToSQL() (sqlStr string, args []interface{}, err error) { if len(d.Suffixes) > 0 { sql.WriteString(" ") - args, _ = d.Suffixes.AppendToSQL(sql, " ", args) + args, _ = d.Suffixes.AppendToSql(sql, " ", args) } sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String()) @@ -167,10 +167,10 @@ func (b UpdateBuilder) Scan(dest ...interface{}) error { // SQL methods -// ToSQL builds the query into a SQL string and bound args. -func (b UpdateBuilder) ToSQL() (string, []interface{}, error) { +// ToSql builds the query into a SQL string and bound args. +func (b UpdateBuilder) ToSql() (string, []interface{}, error) { data := builder.GetStruct(b).(updateData) - return data.ToSQL() + return data.ToSql() } // Prefix adds an expression to the beginning of the query @@ -198,7 +198,7 @@ func (b UpdateBuilder) SetMap(clauses map[string]interface{}) UpdateBuilder { } sort.Strings(keys) for _, key := range keys { - val := clauses[key] + val, _ := clauses[key] b = b.Set(key, val) } return b diff --git a/update_test.go b/update_test.go index fe353b97..13795c3d 100644 --- a/update_test.go +++ b/update_test.go @@ -6,7 +6,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestUpdateBuilderToSQL(t *testing.T) { +func TestUpdateBuilderToSql(t *testing.T) { b := Update(""). Prefix("WITH prefix AS ?", 0). Table("a"). @@ -18,35 +18,35 @@ func TestUpdateBuilderToSQL(t *testing.T) { Offset(5). Suffix("RETURNING ?", 6) - sql, args, err := b.ToSQL() + sql, args, err := b.ToSql() assert.NoError(t, err) - expectedSQL := + expectedSql := "WITH prefix AS ? " + "UPDATE a SET b = ? + 1, c = ? WHERE d = ? " + "ORDER BY e LIMIT 4 OFFSET 5 " + "RETURNING ?" - assert.Equal(t, expectedSQL, sql) + assert.Equal(t, expectedSql, sql) expectedArgs := []interface{}{0, 1, 2, 3, 6} assert.Equal(t, expectedArgs, args) } -func TestUpdateBuilderToSQLErr(t *testing.T) { - _, _, err := Update("").Set("x", 1).ToSQL() +func TestUpdateBuilderToSqlErr(t *testing.T) { + _, _, err := Update("").Set("x", 1).ToSql() assert.Error(t, err) - _, _, err = Update("x").ToSQL() + _, _, err = Update("x").ToSql() assert.Error(t, err) } func TestUpdateBuilderPlaceholders(t *testing.T) { b := Update("test").SetMap(Eq{"x": 1, "y": 2}) - sql, _, _ := b.PlaceholderFormat(Question).ToSQL() + sql, _, _ := b.PlaceholderFormat(Question).ToSql() assert.Equal(t, "UPDATE test SET x = ?, y = ?", sql) - sql, _, _ = b.PlaceholderFormat(Dollar).ToSQL() + sql, _, _ = b.PlaceholderFormat(Dollar).ToSql() assert.Equal(t, "UPDATE test SET x = $1, y = $2", sql) } @@ -54,15 +54,15 @@ func TestUpdateBuilderRunners(t *testing.T) { db := &DBStub{} b := Update("test").Set("x", 1).RunWith(db) - expectedSQL := "UPDATE test SET x = ?" + expectedSql := "UPDATE test SET x = ?" b.Exec() - assert.Equal(t, expectedSQL, db.LastExecSQL) + assert.Equal(t, expectedSql, db.LastExecSql) } func TestUpdateBuilderNoRunner(t *testing.T) { b := Update("test").Set("x", 1) _, err := b.Exec() - assert.Equal(t, ErrRunnerNotSet, err) + assert.Equal(t, RunnerNotSet, err) } diff --git a/where.go b/where.go index 045cb549..3a2d7b70 100644 --- a/where.go +++ b/where.go @@ -10,14 +10,14 @@ func newWherePart(pred interface{}, args ...interface{}) Sqlizer { return &wherePart{pred: pred, args: args} } -func (p wherePart) ToSQL() (sql string, args []interface{}, err error) { +func (p wherePart) ToSql() (sql string, args []interface{}, err error) { switch pred := p.pred.(type) { case nil: // no-op case Sqlizer: - return pred.ToSQL() + return pred.ToSql() case map[string]interface{}: - return Eq(pred).ToSQL() + return Eq(pred).ToSql() case string: sql = pred args = p.args diff --git a/where_test.go b/where_test.go index 692f5d5e..d2109f17 100644 --- a/where_test.go +++ b/where_test.go @@ -8,43 +8,43 @@ import ( "github.com/stretchr/testify/assert" ) -func TestWherePartsAppendToSQL(t *testing.T) { +func TestWherePartsAppendToSql(t *testing.T) { parts := []Sqlizer{ newWherePart("x = ?", 1), newWherePart(nil), newWherePart(Eq{"y": 2}), } sql := &bytes.Buffer{} - args, _ := appendToSQL(parts, sql, " AND ", []interface{}{}) + args, _ := appendToSql(parts, sql, " AND ", []interface{}{}) assert.Equal(t, "x = ? AND y = ?", sql.String()) assert.Equal(t, []interface{}{1, 2}, args) } -func TestWherePartsAppendToSQLErr(t *testing.T) { +func TestWherePartsAppendToSqlErr(t *testing.T) { parts := []Sqlizer{newWherePart(1)} - _, err := appendToSQL(parts, &bytes.Buffer{}, "", []interface{}{}) + _, err := appendToSql(parts, &bytes.Buffer{}, "", []interface{}{}) assert.Error(t, err) } func TestWherePartNil(t *testing.T) { - sql, _, _ := newWherePart(nil).ToSQL() + sql, _, _ := newWherePart(nil).ToSql() assert.Equal(t, "", sql) } func TestWherePartErr(t *testing.T) { - _, _, err := newWherePart(1).ToSQL() + _, _, err := newWherePart(1).ToSql() assert.Error(t, err) } func TestWherePartString(t *testing.T) { - sql, args, _ := newWherePart("x = ?", 1).ToSQL() + sql, args, _ := newWherePart("x = ?", 1).ToSql() assert.Equal(t, "x = ?", sql) assert.Equal(t, []interface{}{1}, args) } func TestWherePartMap(t *testing.T) { test := func(pred interface{}) { - sql, _, _ := newWherePart(pred).ToSQL() + sql, _, _ := newWherePart(pred).ToSql() expect := []string{"x = ? AND y = ?", "y = ? AND x = ?"} if sql != expect[0] && sql != expect[1] { t.Errorf("expected one of %#v, got %#v", expect, sql) From b845a3bbd3aec3ea1562e37eeb463af7c197c383 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 18:01:13 -0400 Subject: [PATCH 6/9] Removing subtests from the predicate ordering tests. --- expr_test.go | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/expr_test.go b/expr_test.go index 39d67961..3fc12649 100644 --- a/expr_test.go +++ b/expr_test.go @@ -32,13 +32,8 @@ func TestGenerateOrderPredicateIndex(t *testing.T) { } for _, tt := range tests { - tt := tt - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - got := GenerateOrderPredicateIndex(tt.args.predicates) - assert.Equal(t, tt.want, got) - }) + got := GenerateOrderPredicateIndex(tt.args.predicates) + assert.Equal(t, tt.want, got) } } From 62e5605adcec30e9b931ee370f4c16fa307234f4 Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 19:35:28 -0400 Subject: [PATCH 7/9] More tests. --- expr_test.go | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/expr_test.go b/expr_test.go index 3fc12649..9ba4b083 100644 --- a/expr_test.go +++ b/expr_test.go @@ -19,16 +19,18 @@ func TestGenerateOrderPredicateIndex(t *testing.T) { args args want []string }{ - {"OrderPredTest1", args{Eq{"one": 1, "two": 2}}, output}, - {"OrderPredTest2", args{Eq{"two": 2, "one": 1}}, output}, - {"OrderPredTest3", args{Lt{"one": 1, "two": 2}}, output}, - {"OrderPredTest4", args{Lt{"two": 2, "one": 1}}, output}, - {"OrderPredTest5", args{Gt{"one": 1, "two": 2}}, output}, - {"OrderPredTest6", args{Gt{"two": 2, "one": 1}}, output}, - {"OrderPredTest7", args{GtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTest8", args{GtOrEq{"two": 2, "one": 1}}, output}, - {"OrderPredTest9", args{LtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTest10", args{LtOrEq{"two": 2, "one": 1}}, output}, + {"OrderPredTest1", args{Eq{}}, []string{}}, + {"OrderPredTest2", args{Eq{"one": 1}}, []string{"one"}}, + {"OrderPredTest3", args{Eq{"one": 1, "two": 2}}, output}, + {"OrderPredTest4", args{Eq{"two": 2, "one": 1}}, output}, + {"OrderPredTest5", args{Lt{"one": 1, "two": 2}}, output}, + {"OrderPredTest6", args{Lt{"two": 2, "one": 1}}, output}, + {"OrderPredTest7", args{Gt{"one": 1, "two": 2}}, output}, + {"OrderPredTest8", args{Gt{"two": 2, "one": 1}}, output}, + {"OrderPredTest9", args{GtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTes10", args{GtOrEq{"two": 2, "one": 1}}, output}, + {"OrderPredTest11", args{LtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTest12", args{LtOrEq{"two": 2, "one": 1}}, output}, } for _, tt := range tests { From 990562c56ec7a4f6da4a813c64d076d6526e892f Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 19:39:05 -0400 Subject: [PATCH 8/9] Even more tests. --- expr_test.go | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/expr_test.go b/expr_test.go index 9ba4b083..1bd38657 100644 --- a/expr_test.go +++ b/expr_test.go @@ -23,14 +23,26 @@ func TestGenerateOrderPredicateIndex(t *testing.T) { {"OrderPredTest2", args{Eq{"one": 1}}, []string{"one"}}, {"OrderPredTest3", args{Eq{"one": 1, "two": 2}}, output}, {"OrderPredTest4", args{Eq{"two": 2, "one": 1}}, output}, - {"OrderPredTest5", args{Lt{"one": 1, "two": 2}}, output}, - {"OrderPredTest6", args{Lt{"two": 2, "one": 1}}, output}, - {"OrderPredTest7", args{Gt{"one": 1, "two": 2}}, output}, - {"OrderPredTest8", args{Gt{"two": 2, "one": 1}}, output}, - {"OrderPredTest9", args{GtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTes10", args{GtOrEq{"two": 2, "one": 1}}, output}, - {"OrderPredTest11", args{LtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTest12", args{LtOrEq{"two": 2, "one": 1}}, output}, + + {"OrderPredTest5", args{Lt{}}, []string{}}, + {"OrderPredTest6", args{Lt{"one": 1}}, []string{"one"}}, + {"OrderPredTest7", args{Lt{"one": 1, "two": 2}}, output}, + {"OrderPredTest8", args{Lt{"two": 2, "one": 1}}, output}, + + {"OrderPredTest9", args{Gt{}}, []string{}}, + {"OrderPredTest10", args{Gt{"one": 1}}, []string{"one"}}, + {"OrderPredTest11", args{Gt{"one": 1, "two": 2}}, output}, + {"OrderPredTest12", args{Gt{"two": 2, "one": 1}}, output}, + + {"OrderPredTest13", args{GtOrEq{}}, []string{}}, + {"OrderPredTest14", args{GtOrEq{"one": 1}}, []string{"one"}}, + {"OrderPredTest15", args{GtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTest16", args{GtOrEq{"two": 2, "one": 1}}, output}, + + {"OrderPredTest17", args{LtOrEq{}}, []string{}}, + {"OrderPredTest18", args{LtOrEq{"one": 1}}, []string{"one"}}, + {"OrderPredTest19", args{LtOrEq{"one": 1, "two": 2}}, output}, + {"OrderPredTest20", args{LtOrEq{"two": 2, "one": 1}}, output}, } for _, tt := range tests { From 4c608fda77fee1d8d8fa739fdcb124d6aa6ba12c Mon Sep 17 00:00:00 2001 From: Brant Fitzsimmons Date: Wed, 26 Apr 2017 19:43:53 -0400 Subject: [PATCH 9/9] No subtests, no need for the test name. --- expr_test.go | 49 ++++++++++++++++++++++++------------------------- 1 file changed, 24 insertions(+), 25 deletions(-) diff --git a/expr_test.go b/expr_test.go index 1bd38657..3c811e05 100644 --- a/expr_test.go +++ b/expr_test.go @@ -15,34 +15,33 @@ func TestGenerateOrderPredicateIndex(t *testing.T) { } tests := []struct { - name string args args want []string }{ - {"OrderPredTest1", args{Eq{}}, []string{}}, - {"OrderPredTest2", args{Eq{"one": 1}}, []string{"one"}}, - {"OrderPredTest3", args{Eq{"one": 1, "two": 2}}, output}, - {"OrderPredTest4", args{Eq{"two": 2, "one": 1}}, output}, - - {"OrderPredTest5", args{Lt{}}, []string{}}, - {"OrderPredTest6", args{Lt{"one": 1}}, []string{"one"}}, - {"OrderPredTest7", args{Lt{"one": 1, "two": 2}}, output}, - {"OrderPredTest8", args{Lt{"two": 2, "one": 1}}, output}, - - {"OrderPredTest9", args{Gt{}}, []string{}}, - {"OrderPredTest10", args{Gt{"one": 1}}, []string{"one"}}, - {"OrderPredTest11", args{Gt{"one": 1, "two": 2}}, output}, - {"OrderPredTest12", args{Gt{"two": 2, "one": 1}}, output}, - - {"OrderPredTest13", args{GtOrEq{}}, []string{}}, - {"OrderPredTest14", args{GtOrEq{"one": 1}}, []string{"one"}}, - {"OrderPredTest15", args{GtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTest16", args{GtOrEq{"two": 2, "one": 1}}, output}, - - {"OrderPredTest17", args{LtOrEq{}}, []string{}}, - {"OrderPredTest18", args{LtOrEq{"one": 1}}, []string{"one"}}, - {"OrderPredTest19", args{LtOrEq{"one": 1, "two": 2}}, output}, - {"OrderPredTest20", args{LtOrEq{"two": 2, "one": 1}}, output}, + {args{Eq{}}, []string{}}, + {args{Eq{"one": 1}}, []string{"one"}}, + {args{Eq{"one": 1, "two": 2}}, output}, + {args{Eq{"two": 2, "one": 1}}, output}, + + {args{Lt{}}, []string{}}, + {args{Lt{"one": 1}}, []string{"one"}}, + {args{Lt{"one": 1, "two": 2}}, output}, + {args{Lt{"two": 2, "one": 1}}, output}, + + {args{Gt{}}, []string{}}, + {args{Gt{"one": 1}}, []string{"one"}}, + {args{Gt{"one": 1, "two": 2}}, output}, + {args{Gt{"two": 2, "one": 1}}, output}, + + {args{GtOrEq{}}, []string{}}, + {args{GtOrEq{"one": 1}}, []string{"one"}}, + {args{GtOrEq{"one": 1, "two": 2}}, output}, + {args{GtOrEq{"two": 2, "one": 1}}, output}, + + {args{LtOrEq{}}, []string{}}, + {args{LtOrEq{"one": 1}}, []string{"one"}}, + {args{LtOrEq{"one": 1, "two": 2}}, output}, + {args{LtOrEq{"two": 2, "one": 1}}, output}, } for _, tt := range tests {