Rename StmtCacher to StmtCache and deprecate NewStmtCacher

Author: GeorgeMac

stmtcacher.go

@@ -21,22 +21,22 @@ type DBProxy interface {
 	Preparer
 }
 
-// NOTE: NewStmtCacher is defined in stmtcacher_ctx.go (Go >= 1.8) or stmtcacher_noctx.go (Go < 1.8).
+// NOTE: NewStmtCache is defined in stmtcacher_ctx.go (Go >= 1.8) or stmtcacher_noctx.go (Go < 1.8).
 
-// StmtCacher wraps and delegates down to a Preparer type
+// StmtCache wraps and delegates down to a Preparer type
 //
 // It also automatically prepares all statements sent to the underlying Preparer calls
 // for Exec, Query and QueryRow and caches the returns *sql.Stmt using the provided
 // query as the key. So that it can be automatically re-used.
-type StmtCacher struct {
+type StmtCache struct {
 	prep  Preparer
 	cache map[string]*sql.Stmt
 	mu    sync.Mutex
 }
 
 // Prepare delegates down to the underlying Preparer and caches the result
 // using the provided query as a key
-func (sc *StmtCacher) Prepare(query string) (*sql.Stmt, error) {
+func (sc *StmtCache) Prepare(query string) (*sql.Stmt, error) {
 	sc.mu.Lock()
 	defer sc.mu.Unlock()
 
@@ -52,7 +52,7 @@ func (sc *StmtCacher) Prepare(query string) (*sql.Stmt, error) {
 }
 
 // Exec delegates down to the underlying Preparer using a prepared statement
-func (sc *StmtCacher) Exec(query string, args ...interface{}) (res sql.Result, err error) {
+func (sc *StmtCache) Exec(query string, args ...interface{}) (res sql.Result, err error) {
 	stmt, err := sc.Prepare(query)
 	if err != nil {
 		return
@@ -61,7 +61,7 @@ func (sc *StmtCacher) Exec(query string, args ...interface{}) (res sql.Result, e
 }
 
 // Query delegates down to the underlying Preparer using a prepared statement
-func (sc *StmtCacher) Query(query string, args ...interface{}) (rows *sql.Rows, err error) {
+func (sc *StmtCache) Query(query string, args ...interface{}) (rows *sql.Rows, err error) {
 	stmt, err := sc.Prepare(query)
 	if err != nil {
 		return
@@ -70,7 +70,7 @@ func (sc *StmtCacher) Query(query string, args ...interface{}) (rows *sql.Rows,
 }
 
 // QueryRow delegates down to the underlying Preparer using a prepared statement
-func (sc *StmtCacher) QueryRow(query string, args ...interface{}) RowScanner {
+func (sc *StmtCache) QueryRow(query string, args ...interface{}) RowScanner {
 	stmt, err := sc.Prepare(query)
 	if err != nil {
 		return &Row{err: err}
@@ -79,7 +79,7 @@ func (sc *StmtCacher) QueryRow(query string, args ...interface{}) RowScanner {
 }
 
 // Clear removes and closes all the currently cached prepared statements
-func (sc *StmtCacher) Clear() (err error) {
+func (sc *StmtCache) Clear() (err error) {
 	sc.mu.Lock()
 	defer sc.mu.Unlock()
 
@@ -113,7 +113,7 @@ type stmtCacheProxy struct {
 }
 
 func NewStmtCacherProxy(db *sql.DB) DBProxyBeginner {
-	return &stmtCacheProxy{DBProxy: NewStmtCacher(db), db: db}
+	return &stmtCacheProxy{DBProxy: NewStmtCache(db), db: db}
 }
 
 func (sp *stmtCacheProxy) Begin() (*sql.Tx, error) {

stmtcacher_ctx.go

@@ -24,16 +24,23 @@ type DBProxyContext interface {
 	PreparerContext
 }
 
-// NewStmtCacher returns a DBProxy wrapping prep that caches Prepared Stmts.
+// NewStmtCache returns a *StmtCache wrapping a PreparerContext that caches Prepared Stmts.
 //
 // Stmts are cached based on the string value of their queries.
+func NewStmtCache(prep PreparerContext) *StmtCache {
+	return &StmtCache{prep: prep, cache: make(map[string]*sql.Stmt)}
+}
+
+// NewStmtCacher is deprecated
+//
+// Use NewStmtCache instead
 func NewStmtCacher(prep PreparerContext) DBProxyContext {
-	return &StmtCacher{prep: prep, cache: make(map[string]*sql.Stmt)}
+	return NewStmtCache(prep)
 }
 
 // PrepareContext delegates down to the underlying PreparerContext and caches the result
 // using the provided query as a key
-func (sc *StmtCacher) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
+func (sc *StmtCache) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
 	ctxPrep, ok := sc.prep.(PreparerContext)
 	if !ok {
 		return nil, NoContextSupport
@@ -52,7 +59,7 @@ func (sc *StmtCacher) PrepareContext(ctx context.Context, query string) (*sql.St
 }
 
 // ExecContext delegates down to the underlying PreparerContext using a prepared statement
-func (sc *StmtCacher) ExecContext(ctx context.Context, query string, args ...interface{}) (res sql.Result, err error) {
+func (sc *StmtCache) ExecContext(ctx context.Context, query string, args ...interface{}) (res sql.Result, err error) {
 	stmt, err := sc.PrepareContext(ctx, query)
 	if err != nil {
 		return
@@ -61,7 +68,7 @@ func (sc *StmtCacher) ExecContext(ctx context.Context, query string, args ...int
 }
 
 // QueryContext delegates down to the underlying PreparerContext using a prepared statement
-func (sc *StmtCacher) QueryContext(ctx context.Context, query string, args ...interface{}) (rows *sql.Rows, err error) {
+func (sc *StmtCache) QueryContext(ctx context.Context, query string, args ...interface{}) (rows *sql.Rows, err error) {
 	stmt, err := sc.PrepareContext(ctx, query)
 	if err != nil {
 		return
@@ -70,7 +77,7 @@ func (sc *StmtCacher) QueryContext(ctx context.Context, query string, args ...in
 }
 
 // QueryRowContext delegates down to the underlying PreparerContext using a prepared statement
-func (sc *StmtCacher) QueryRowContext(ctx context.Context, query string, args ...interface{}) RowScanner {
+func (sc *StmtCache) QueryRowContext(ctx context.Context, query string, args ...interface{}) RowScanner {
 	stmt, err := sc.PrepareContext(ctx, query)
 	if err != nil {
 		return &Row{err: err}

stmtcacher_ctx_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestStmtCacherPrepareContext(t *testing.T) {
 	db := &DBStub{}
-	sc := NewStmtCacher(db)
+	sc := NewStmtCache(db)
 	query := "SELECT 1"
 
 	sc.PrepareContext(ctx, query)

stmtcacher_noctx.go

@@ -9,6 +9,13 @@ import (
 // NewStmtCacher returns a DBProxy wrapping prep that caches Prepared Stmts.
 //
 // Stmts are cached based on the string value of their queries.
-func NewStmtCacher(prep Preparer) DBProxy {
+func NewStmtCache(prep Preparer) *StmtCache {
 	return &StmtCacher{prep: prep, cache: make(map[string]*sql.Stmt)}
 }
+
+// NewStmtCacher is deprecated
+//
+// Use NewStmtCache instead
+func NewStmtCacher(prep Preparer) DBProxy {
+	return NewStmtCache(prep)
+}

stmtcacher_test.go

@@ -4,12 +4,11 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestStmtCacherPrepare(t *testing.T) {
+func TestStmtCachePrepare(t *testing.T) {
 	db := &DBStub{}
-	sc := NewStmtCacher(db)
+	sc := NewStmtCache(db)
 	query := "SELECT 1"
 
 	sc.Prepare(query)
@@ -19,9 +18,7 @@ func TestStmtCacherPrepare(t *testing.T) {
 	assert.Equal(t, 1, db.PrepareCount, "expected 1 Prepare, got %d", db.PrepareCount)
 
 	// clear statement cache
-	clearer, ok := sc.(*StmtCacher)
-	require.True(t, ok)
-	assert.Nil(t, clearer.Clear())
+	assert.Nil(t, sc.Clear())
 
 	// should prepare the query again
 	sc.Prepare(query)