Rewrite stmt cache for transactions

stmtcacher.go

@@ -88,3 +88,67 @@ func NewStmtCacheProxy(db *sql.DB) DBProxyBeginner {
 func (sp *stmtCacheProxy) Begin() (*sql.Tx, error) {
 	return sp.db.Begin()
 }
+
+// DBTransactionProxy wraps transaction and includes DBProxy interface
+type DBTransactionProxy interface {
+	DBProxy
+	Begin() error
+	Commit() error
+	Rollback() error
+}
+
+type stmtCacheTransactionProxy struct {
+	DBProxy
+	db          *sql.DB
+	transaction *sql.Tx
+}
+
+// NewStmtCacheTransactionProxy returns a DBTransactionProxy
+// wrapping an open transaction in stmtCacher.
+// You should use Begin() each time you want a new transaction and
+// cache will be valid only for that transaction.
+// By default without calling Begin proxy will use simple stmtCacher
+//
+// Usage example:
+//	proxy := sq.NewStmtCacheTransactionProxy(db)
+//	mydb := sq.StatementBuilder.RunWith(proxy)
+//	insertUsers := mydb.Insert("users").Columns("name")
+//	insertUsers.Values("username1").Exec()
+//	insertUsers.Values("username2").Exec()
+//	proxy.Commit()
+//
+//	proxy.Begin()
+//	insertPets := mydb.Insert("pets").Columns("name", "username")
+//	insertPets.Values("petname1", "username1").Exec()
+//	insertPets.Values("petname2", "username1").Exec()
+//	proxy.Commit()
+func NewStmtCacheTransactionProxy(db *sql.DB) (proxy DBTransactionProxy) {
+	return &stmtCacheTransactionProxy{DBProxy: NewStmtCacher(db), db: db}
+}
+
+func (s *stmtCacheTransactionProxy) Begin() (err error) {
+	tr, err := s.db.Begin()
+
+	if err != nil {
+		return
+	}
+
+	s.DBProxy = NewStmtCacher(tr)
+	s.transaction = tr
+
+	return
+}
+
+func (s *stmtCacheTransactionProxy) Commit() error {
+	defer s.resetProxy()
+	return s.transaction.Commit()
+}
+
+func (s *stmtCacheTransactionProxy) Rollback() error {
+	defer s.resetProxy()
+	return s.transaction.Rollback()
+}
+
+func (s *stmtCacheTransactionProxy) resetProxy() {
+	s.DBProxy = NewStmtCacher(s.db)
+}