try delete cache key on error; bug in remapPlaceholders

CHANGES.md

@@ -1,4 +1,14 @@
-# Changes from legacy to v1
+## v1.1.0
+
+*   [Caching](https://github.com/mgutz/dat#caching) - caching with Redis or (in-memory for testing)
+*   [LogQueriesThreshold](https://github.com/mgutz/dat#tracing-sql) - log slow queries
+*   dat.Null* creators
+*   fix resource cleanup
+*   fix duplicate error logging
+*   include RFC339Nano in NullTime parsing
+*   HUGE BUG in remapPlaceholders
+
+## v1.0.0
 
 *   Original dat moved to legacy branch.
 

Gododir/generate.go

@@ -35,15 +35,15 @@ package dat
 func generateTasks(p *do.Project) {
 	p.Task("builder-boilerplate", nil, func(c *do.Context) {
 		context := do.M{
-			"builders": []string{"DeleteBuilder", "InsectBuilder",
+			"builders": []string{"CallBuilder", "DeleteBuilder", "InsectBuilder",
 				"InsertBuilder", "RawBuilder", "SelectBuilder", "SelectDocBuilder",
 				"UpdateBuilder", "UpsertBuilder"},
 		}
 
 		s, err := util.StrTemplate(builderTemplate, context)
 		c.Check(err, "Unalbe ")
 
-		ioutil.WriteFile("v1/builders_generated.go", []byte(s), 0644)
-		c.Run("go fmt v1/builders_generated.go")
+		ioutil.WriteFile("builders_generated.go", []byte(s), 0644)
+		c.Run("go fmt builders_generated.go")
 	}).Desc("Generates builder boilerplate code")
 }

Gododir/main.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+
 	_ "github.com/lib/pq"
 	do "gopkg.in/godo.v2"
 )
@@ -16,9 +18,16 @@ func tasks(p *do.Project) {
 	p.Task("createdb", nil, createdb).Description("Creates test database")
 
 	p.Task("test", nil, func(c *do.Context) {
+		c.Run(`go test -race`)
+		c.Run(`go test -race`, do.M{"$in": "sqlx-runner"})
+	}).Src("**/*.go").
+		Desc("test with -race flag")
+
+	p.Task("test-fast", nil, func(c *do.Context) {
 		c.Run(`go test`)
 		c.Run(`go test`, do.M{"$in": "sqlx-runner"})
-	}).Src("**/*.go")
+	}).Src("**/*.go").
+		Desc("fater test without -race flag")
 
 	p.Task("test-dir", nil, func(c *do.Context) {
 		dir := c.Args.NonFlags()[0]
@@ -36,6 +45,10 @@ func tasks(p *do.Project) {
 		`)
 	})
 
+	p.Task("hello", nil, func(*do.Context) {
+		fmt.Println("hello?")
+	})
+
 	p.Task("bench", nil, func(c *do.Context) {
 		// Bash("go test -bench . -benchmem 2>/dev/null | column -t")
 		// Bash("go test -bench . -benchmem 2>/dev/null | column -t", In{"sqlx-runner"})
@@ -62,6 +75,33 @@ func tasks(p *do.Project) {
 
 	p.Task("example", nil, func(c *do.Context) {
 	})
+
+	p.Task("lint", nil, func(c *do.Context) {
+		c.Bash(`
+		echo Directory=.
+		golint
+
+		cd sqlx-runner
+		echo
+		echo Directory=sqlx-runner
+		golint
+
+		cd ../kvs
+		echo
+		echo Directory=kvs
+		golint
+
+		cd ../postgres
+		echo
+		echo Directory=postgres
+		golint
+		`)
+	})
+
+	p.Task("mocks", nil, func(c *do.Context) {
+		// go get github.com/vektra/mockery
+		c.Run("mockery --dir=kvs --all")
+	})
 }
 
 func main() {

README.md

@@ -23,7 +23,7 @@ library for Go.
     DB.SQL(`SELECT * FROM people LIMIT 10`).QueryStructs(&people)
     ```
 
-*   JSON Document retrieval (single trip to Postgres!, requires Postgres 9.3+)
+*   JSON Document retrieval (single trip to Postgres, requires Postgres 9.3+)
 
     ```go
     DB.SelectDoc("id", "user_name", "avatar").
@@ -140,7 +140,7 @@ func init() {
         panic("Could not ping database")
     }
 
-    // set to reasonable values
+    // set to reasonable values for production
     db.SetMaxIdleConns(4)
     db.SetMaxOpenConns(16)
 
@@ -163,7 +163,7 @@ type Post struct {
     Body      string        `db:"body"`
     UserID    int64         `db:"user_id"`
     State     string        `db:"state"`
-    UpdatedAt dat.Nulltime  `db:"updated_at"`
+    UpdatedAt dat.NullTime  `db:"updated_at"`
     CreatedAt dat.NullTime  `db:"created_at"`
 }
 
@@ -260,7 +260,6 @@ DB.InsertInto("payments").
 // ensure session user can only update his information
 DB.Update("users").
     SetWhitelist(user, "user_name", "avatar", "quote").
-    Record(userData).
     Where("id = $1", session.UserID).
     Exec()
 ```
@@ -282,7 +281,7 @@ b.MustInterpolate() == "SELECT * FROM posts WHERE id IN (10,20,30,40,50)"
 `dat` uses [logxi](https://github.com/mgutz/logxi) for logging. By default,
 *logxi* logs all warnings and errors to the console. `dat` logs the
 SQL and its arguments on any error. In addition, `dat` logs slow queries
-as warnings if `LogQueriesThreshold > 0`
+as warnings if `runner.LogQueriesThreshold > 0`
 
 To trace all SQL, set environment variable
 
@@ -298,7 +297,7 @@ Use `Returning` and `QueryStruct` to insert and update struct fields in one
 trip
 
 ```go
-post := Post{Title: "Swith to Postgres", State: "open"}
+var post Post
 
 err := DB.
     InsertInto("posts").
@@ -316,15 +315,15 @@ post := Post{Title: "Go is awesome", State: "open"}
 err := DB.
     InsertInto("posts").
     Blacklist("id", "user_id", "created_at", "updated_at").
-    Record(post).
+    Record(&post).
     Returning("id", "created_at", "updated_at").
     QueryStruct(&post)
 
 // use wildcard to include all columns
 err := DB.
     InsertInto("posts").
     Whitelist("*").
-    Record(post).
+    Record(&post).
     Returning("id", "created_at", "updated_at").
     QueryStruct(&post)
 
@@ -491,7 +490,7 @@ result, err = DB.
 
 ### Joins
 
-Define JOINs as arguments to `From`
+Define JOINs in argument to `From`
 
 ``` go
 err = DB.
@@ -594,6 +593,52 @@ func getUsers(conn runner.Connection) ([]*dto.Users, error) {
 }
 ```
 
+#### Nested Transactions
+
+Nested transaction logic is as follows:
+
+*   If `Commit` is called in a nested transaction, the operation results in no operation (NOOP).
+    Only the top level `Commit` commits the transaction to the database.
+
+*   If `Rollback` is called in a nested transaction, then the entire
+    transaction is rolled back. `Tx.IsRollbacked` is set to true.
+
+*   Either `defer Tx.AutoCommit()` or `defer Tx.AutoRollback()` **MUST BE CALLED**
+    for each corresponding `Begin`. The internal state of nested transactions is
+    tracked in these two methods.
+
+```go
+func nested(conn runner.Connection) error {
+    tx, err := conn.Begin()
+    if err != nil {
+        return err
+    }
+    defer tx.AutoRollback()
+
+    _, err := tx.SQL(`INSERT INTO users (email) values $1`, 'me@home.com').Exec()
+    if err != nil {
+        return err
+    }
+    // prevents AutoRollback
+    tx.Commit()
+}
+
+func top() {
+    tx, err := DB.Begin()
+    if err != nil {
+        logger.Fatal("Could not create transaction")
+    }
+    defer tx.AutoRollback()
+
+    err := nested(tx)
+    if err != nil {
+        return
+    }
+    // top level commits the transaction
+    tx.Commit()
+}
+```
+
 ### Dates
 
 Use `dat.NullTime` type to properly handle nullable dates
@@ -661,80 +706,6 @@ err := DB.
     QueryStruct(&post)
 ```
 
-### Transactions
-
-```go
-// Start transaction
-tx, err := DB.Begin()
-if err != nil {
-    return err
-}
-// safe to call tx.Rollback() or tx.Commit() later
-defer tx.AutoRollback()
-
-// Issue statements that might cause errors
-res, err := tx.
-    Update("posts").
-    Set("state", "deleted").
-    Where("deleted_at IS NOT NULL").
-    Exec()
-
-if err != nil {
-    // AutoRollback will rollback the transaction
-    return err
-}
-
-// commit to prevent AutoRollback from rolling back the transaction
-tx.Commit()
-return nil
-```
-
-#### Nested Transactions
-
-Nested transaction logic is as follows:
-
-*   If `Commit` is called in a nested transaction, the operation results in no operatoin (NOOP).
-    Only the top level `Commit` commits the transaction to the database.
-
-*   If `Rollback` is called in a nested transaction, then the entire
-    transaction is rolled back. `Tx.IsRollbacked` is set to true.
-
-*   Either `defer Tx.AutoCommit()` or `defer Tx.AutoRollback()` **MUST BE CALLED**
-    for each corresponding `Begin`. The internal state of nested transactions is
-    tracked in these two methods.
-
-```go
-func nested(conn runner.Connection) error {
-    tx, err := conn.Begin()
-    if err != nil {
-        return err
-    }
-    defer tx.AutoRollback()
-
-    _, err := tx.SQL(`INSERT INTO users (email) values $1`, 'me@home.com').Exec()
-    if err != nil {
-        return err
-    }
-    // prevents AutoRollback
-    tx.Commit()
-}
-
-func top() {
-    tx, err := DB.Begin()
-    if err != nil {
-        logger.Fatal("Could not create transaction")
-    }
-    defer tx.AutoRollback()
-
-    err := nested(tx)
-    if err != nil {
-        return
-    }
-    // top level commits the transaction
-    tx.Commit()
-}
-```
-
 ### Caching
 
 dat implements caching backed by an in-memory or Redis store. The in-memory store

builder.go

@@ -1,15 +1,5 @@
 package dat
 
-import "time"
-
-// Cacher caches query results.
-type Cacher interface {
-	// Cache caches the result of a Select or SelectDoc. If id is not provided, an FNV checksum
-	// of the SQL is used as the id. (If interpolation is set, arguments are hashed). Use invalidate to
-	// immediately invalidate the cache to force setting its value.
-	Cache(id string, duration time.Duration, invalidate bool)
-}
-
 // Builder interface is used to tie SQL generators to executors.
 type Builder interface {
 	// ToSQL builds the SQL and arguments from builder.

execer.go

@@ -27,7 +27,7 @@ var nullExecer = &panicExecer{}
 
 // panicExecer is the execer assigned when a builder is first created.
 // panicExecer raises a panic if any of the Execer methods are called
-// directly from dat. Runners override the execer to communicate with a live
+// directly from dat. Runners override the execer to work with a live
 // database.
 type panicExecer struct{}
 

insert.go

@@ -43,7 +43,7 @@ func (b *InsertBuilder) Blacklist(columns ...string) *InsertBuilder {
 }
 
 // Whitelist defines a whitelist of columns to be inserted. To
-// specify all columsn of a record use "*".
+// specify all columns of a record use "*".
 func (b *InsertBuilder) Whitelist(columns ...string) *InsertBuilder {
 	b.cols = columns
 	return b

interpolate.go

@@ -63,7 +63,7 @@ func Interpolate(sql string, vals []interface{}) (string, []interface{}, error)
 	// Args with a blank query is an error
 	if sql == "" {
 		if lenVals != 0 {
-			return "", nil, ErrArgumentMismatch
+			return "", nil, logger.Error("Interpolation error", "err", ErrArgumentMismatch, "sql", sql, "args", vals)
 		}
 		return "", nil, nil
 	}
@@ -75,13 +75,13 @@ func Interpolate(sql string, vals []interface{}) (string, []interface{}, error)
 		// No args for a query with place holders is an error
 		if lenVals == 0 {
 			if hasPlaceholders {
-				return "", nil, ErrArgumentMismatch
+				return "", nil, logger.Error("Interpolation error", "err", ErrArgumentMismatch, "sql", sql, "args", vals)
 			}
 			return sql, nil, nil
 		}
 
 		if lenVals > 0 && !hasPlaceholders {
-			return "", nil, ErrArgumentMismatch
+			return "", nil, logger.Error("Interpolation error", "err", ErrArgumentMismatch, "sql", sql, "args", vals)
 		}
 
 		if !hasPlaceholders {

interpolate_test.go

@@ -61,9 +61,9 @@ func TestInterpolateInts(t *testing.T) {
 		uint64(10),
 	}
 
-	str, _, err := Interpolate("SELECT * FROM x WHERE a = $1 AND b = $2 AND c = $3 AND d = $4 AND e = $5 AND f = $6 AND g = $7 AND h = $8 AND i = $9 AND j = $10", args)
+	str, _, err := Interpolate("SELECT * FROM x WHERE a = $1 AND b = $2 AND c = $3 AND d = $4 AND e = $5 AND f = $6 AND g = $7 AND h = $8 AND i = $9 AND j = $1", args)
 	assert.NoError(t, err)
-	assert.Equal(t, str, "SELECT * FROM x WHERE a = 1 AND b = -2 AND c = 3 AND d = 4 AND e = 5 AND f = 6 AND g = 7 AND h = 8 AND i = 9 AND j = 10")
+	assert.Equal(t, str, "SELECT * FROM x WHERE a = 1 AND b = -2 AND c = 3 AND d = 4 AND e = 5 AND f = 6 AND g = 7 AND h = 8 AND i = 9 AND j = 1")
 }
 
 func TestInterpolateBools(t *testing.T) {