Update Context support

- Preserve backward compatibility in interfaces
- Support all statement builders
- Support PrepareContext in stmtCacher
- Update Travis config

Author: lann

.travis.yml

@@ -1,11 +1,8 @@
 language: go
 
 go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - 1.4
-  - 1.5
+  - 1.7
+  - 1.8
   - tip
 
 # Setting sudo access to false will let Travis CI use containers rather than

delete_ctx.go

@@ -0,0 +1,27 @@
+// +build go1.8
+
+package squirrel
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/lann/builder"
+)
+
+func (d *deleteData) ExecContext(ctx context.Context) (sql.Result, error) {
+	if d.RunWith == nil {
+		return nil, RunnerNotSet
+	}
+	ctxRunner, ok := d.RunWith.(ExecerContext)
+	if !ok {
+		return nil, NoContextSupport
+	}
+	return ExecContextWith(ctx, ctxRunner, d)
+}
+
+// ExecContext builds and ExecContexts the query with the Runner set by RunWith.
+func (b DeleteBuilder) ExecContext(ctx context.Context) (sql.Result, error) {
+	data := builder.GetStruct(b).(deleteData)
+	return data.ExecContext(ctx)
+}

delete_ctx_test.go

@@ -0,0 +1,26 @@
+// +build go1.8
+
+package squirrel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDeleteBuilderContextRunners(t *testing.T) {
+	db := &DBStub{}
+	b := Delete("test").Where("x = ?", 1).RunWith(db)
+
+	expectedSql := "DELETE FROM test WHERE x = ?"
+
+	b.ExecContext(ctx)
+	assert.Equal(t, expectedSql, db.LastExecSql)
+}
+
+func TestDeleteBuilderContextNoRunner(t *testing.T) {
+	b := Delete("test")
+
+	_, err := b.ExecContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+}

insert_ctx.go

@@ -0,0 +1,69 @@
+// +build go1.8
+
+package squirrel
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/lann/builder"
+)
+
+func (d *insertData) ExecContext(ctx context.Context) (sql.Result, error) {
+	if d.RunWith == nil {
+		return nil, RunnerNotSet
+	}
+	ctxRunner, ok := d.RunWith.(ExecerContext)
+	if !ok {
+		return nil, NoContextSupport
+	}
+	return ExecContextWith(ctx, ctxRunner, d)
+}
+
+func (d *insertData) QueryContext(ctx context.Context) (*sql.Rows, error) {
+	if d.RunWith == nil {
+		return nil, RunnerNotSet
+	}
+	ctxRunner, ok := d.RunWith.(QueryerContext)
+	if !ok {
+		return nil, NoContextSupport
+	}
+	return QueryContextWith(ctx, ctxRunner, d)
+}
+
+func (d *insertData) QueryRowContext(ctx context.Context) RowScanner {
+	if d.RunWith == nil {
+		return &Row{err: RunnerNotSet}
+	}
+	queryRower, ok := d.RunWith.(QueryRowerContext)
+	if !ok {
+		if _, ok := d.RunWith.(QueryerContext); !ok {
+			return &Row{err: RunnerNotQueryRunner}
+		}
+		return &Row{err: NoContextSupport}
+	}
+	return QueryRowContextWith(ctx, queryRower, d)
+}
+
+// ExecContext builds and ExecContexts the query with the Runner set by RunWith.
+func (b InsertBuilder) ExecContext(ctx context.Context) (sql.Result, error) {
+	data := builder.GetStruct(b).(insertData)
+	return data.ExecContext(ctx)
+}
+
+// QueryContext builds and QueryContexts the query with the Runner set by RunWith.
+func (b InsertBuilder) QueryContext(ctx context.Context) (*sql.Rows, error) {
+	data := builder.GetStruct(b).(insertData)
+	return data.QueryContext(ctx)
+}
+
+// QueryRowContext builds and QueryRowContexts the query with the Runner set by RunWith.
+func (b InsertBuilder) QueryRowContext(ctx context.Context) RowScanner {
+	data := builder.GetStruct(b).(insertData)
+	return data.QueryRowContext(ctx)
+}
+
+// ScanContext is a shortcut for QueryRowContext().Scan.
+func (b InsertBuilder) ScanContext(ctx context.Context, dest ...interface{}) error {
+	return b.QueryRowContext(ctx).Scan(dest...)
+}

insert_ctx_test.go

@@ -0,0 +1,42 @@
+// +build go1.8
+
+package squirrel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInsertBuilderContextRunners(t *testing.T) {
+	db := &DBStub{}
+	b := Insert("test").Values(1).RunWith(db)
+
+	expectedSql := "INSERT INTO test VALUES (?)"
+
+	b.ExecContext(ctx)
+	assert.Equal(t, expectedSql, db.LastExecSql)
+
+	b.QueryContext(ctx)
+	assert.Equal(t, expectedSql, db.LastQuerySql)
+
+	b.QueryRowContext(ctx)
+	assert.Equal(t, expectedSql, db.LastQueryRowSql)
+
+	err := b.ScanContext(ctx)
+	assert.NoError(t, err)
+}
+
+func TestInsertBuilderContextNoRunner(t *testing.T) {
+	b := Insert("test").Values(1)
+
+	_, err := b.ExecContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+
+	_, err = b.QueryContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+
+	err = b.ScanContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+}
+

select_go18.go renamed to select_ctx.go

@@ -13,23 +13,34 @@ func (d *selectData) ExecContext(ctx context.Context) (sql.Result, error) {
 	if d.RunWith == nil {
 		return nil, RunnerNotSet
 	}
-	return ExecContextWith(ctx, d.RunWith, d)
+	ctxRunner, ok := d.RunWith.(ExecerContext)
+	if !ok {
+		return nil, NoContextSupport
+	}
+	return ExecContextWith(ctx, ctxRunner, d)
 }
 
 func (d *selectData) QueryContext(ctx context.Context) (*sql.Rows, error) {
 	if d.RunWith == nil {
 		return nil, RunnerNotSet
 	}
-	return QueryContextWith(ctx, d.RunWith, d)
+	ctxRunner, ok := d.RunWith.(QueryerContext)
+	if !ok {
+		return nil, NoContextSupport
+	}
+	return QueryContextWith(ctx, ctxRunner, d)
 }
 
 func (d *selectData) QueryRowContext(ctx context.Context) RowScanner {
 	if d.RunWith == nil {
 		return &Row{err: RunnerNotSet}
 	}
-	queryRower, ok := d.RunWith.(QueryRower)
+	queryRower, ok := d.RunWith.(QueryRowerContext)
 	if !ok {
-		return &Row{err: RunnerNotQueryRunner}
+		if _, ok := d.RunWith.(QueryerContext); !ok {
+			return &Row{err: RunnerNotQueryRunner}
+		}
+		return &Row{err: NoContextSupport}
 	}
 	return QueryRowContextWith(ctx, queryRower, d)
 }
@@ -51,3 +62,8 @@ func (b SelectBuilder) QueryRowContext(ctx context.Context) RowScanner {
 	data := builder.GetStruct(b).(selectData)
 	return data.QueryRowContext(ctx)
 }
+
+// ScanContext is a shortcut for QueryRowContext().Scan.
+func (b SelectBuilder) ScanContext(ctx context.Context, dest ...interface{}) error {
+	return b.QueryRowContext(ctx).Scan(dest...)
+}

select_ctx_test.go

@@ -0,0 +1,42 @@
+// +build go1.8
+
+package squirrel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSelectBuilderContextRunners(t *testing.T) {
+	db := &DBStub{}
+	b := Select("test").RunWith(db)
+
+	expectedSql := "SELECT test"
+
+	b.ExecContext(ctx)
+	assert.Equal(t, expectedSql, db.LastExecSql)
+
+	b.QueryContext(ctx)
+	assert.Equal(t, expectedSql, db.LastQuerySql)
+
+	b.QueryRowContext(ctx)
+	assert.Equal(t, expectedSql, db.LastQueryRowSql)
+
+	err := b.ScanContext(ctx)
+	assert.NoError(t, err)
+}
+
+func TestSelectBuilderContextNoRunner(t *testing.T) {
+	b := Select("test")
+
+	_, err := b.ExecContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+
+	_, err = b.QueryContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+
+	err = b.ScanContext(ctx)
+	assert.Equal(t, RunnerNotSet, err)
+}
+

squirrel.go

@@ -20,6 +20,27 @@ type Sqlizer interface {
 	ToSql() (string, []interface{}, error)
 }
 
+// Execer is the interface that wraps the Exec method.
+//
+// Exec executes the given query as implemented by database/sql.Exec.
+type Execer interface {
+	Exec(query string, args ...interface{}) (sql.Result, error)
+}
+
+// Queryer is the interface that wraps the Query method.
+//
+// Query executes the given query as implemented by database/sql.Query.
+type Queryer interface {
+	Query(query string, args ...interface{}) (*sql.Rows, error)
+}
+
+// QueryRower is the interface that wraps the QueryRow method.
+//
+// QueryRow executes the given query as implemented by database/sql.QueryRow.
+type QueryRower interface {
+	QueryRow(query string, args ...interface{}) RowScanner
+}
+
 // BaseRunner groups the Execer and Queryer interfaces.
 type BaseRunner interface {
 	Execer

squirrel_go18.go renamed to squirrel_ctx.go

@@ -5,29 +5,30 @@ package squirrel
 import (
 	"context"
 	"database/sql"
+	"errors"
 )
 
-// Execer is the interface that wraps the Exec method.
+// NoContextSupport is returned if a db doesn't support Context.
+var NoContextSupport = errors.New("DB does not support Context")
+
+// ExecerContext is the interface that wraps the ExecContext method.
 //
-// Exec executes the given query as implemented by database/sql.Exec.
-type Execer interface {
-	Exec(query string, args ...interface{}) (sql.Result, error)
+// Exec executes the given query as implemented by database/sql.ExecContext.
+type ExecerContext interface {
 	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
 }
 
-// Queryer is the interface that wraps the Query method.
+// QueryerContext is the interface that wraps the QueryContext method.
 //
-// Query executes the given query as implemented by database/sql.Query.
-type Queryer interface {
-	Query(query string, args ...interface{}) (*sql.Rows, error)
+// QueryContext executes the given query as implemented by database/sql.QueryContext.
+type QueryerContext interface {
 	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
 }
 
-// QueryRower is the interface that wraps the QueryRow method.
+// QueryRowerContext is the interface that wraps the QueryRowContext method.
 //
-// QueryRow executes the given query as implemented by database/sql.QueryRow.
-type QueryRower interface {
-	QueryRow(query string, args ...interface{}) RowScanner
+// QueryRowContext executes the given query as implemented by database/sql.QueryRowContext.
+type QueryRowerContext interface {
 	QueryRowContext(ctx context.Context, query string, args ...interface{}) RowScanner
 }
 
@@ -40,7 +41,7 @@ func (r *txRunner) QueryRowContext(ctx context.Context, query string, args ...in
 }
 
 // ExecContextWith ExecContexts the SQL returned by s with db.
-func ExecContextWith(ctx context.Context, db Execer, s Sqlizer) (res sql.Result, err error) {
+func ExecContextWith(ctx context.Context, db ExecerContext, s Sqlizer) (res sql.Result, err error) {
 	query, args, err := s.ToSql()
 	if err != nil {
 		return
@@ -49,7 +50,7 @@ func ExecContextWith(ctx context.Context, db Execer, s Sqlizer) (res sql.Result,
 }
 
 // QueryContextWith QueryContexts the SQL returned by s with db.
-func QueryContextWith(ctx context.Context, db Queryer, s Sqlizer) (rows *sql.Rows, err error) {
+func QueryContextWith(ctx context.Context, db QueryerContext, s Sqlizer) (rows *sql.Rows, err error) {
 	query, args, err := s.ToSql()
 	if err != nil {
 		return
@@ -58,7 +59,7 @@ func QueryContextWith(ctx context.Context, db Queryer, s Sqlizer) (rows *sql.Row
 }
 
 // QueryRowContextWith QueryRowContexts the SQL returned by s with db.
-func QueryRowContextWith(ctx context.Context, db QueryRower, s Sqlizer) RowScanner {
+func QueryRowContextWith(ctx context.Context, db QueryRowerContext, s Sqlizer) RowScanner {
 	query, args, err := s.ToSql()
 	return &Row{RowScanner: db.QueryRowContext(ctx, query, args...), err: err}
 }