Unexport borp.DbMap from db.WrappedMap

This was allowing some methods to pass through to the underlying
borp.DbMap accidentally, without getting wrapped.

Introduce accessors to get the underlying *borp.DbMap or *sql.DB when
needed.

Author: jsha

db/map.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"reflect"
 	"regexp"
 
 	"github.com/go-sql-driver/mysql"
@@ -60,106 +61,134 @@ func IsDuplicate(err error) bool {
 // WrappedMap wraps a *borp.DbMap such that its major functions wrap error
 // results in ErrDatabaseOp instances before returning them to the caller.
 type WrappedMap struct {
-	*borp.DbMap
+	dbMap *borp.DbMap
+}
+
+func NewWrappedMap(dbMap *borp.DbMap) *WrappedMap {
+	return &WrappedMap{dbMap: dbMap}
+}
+
+func (m *WrappedMap) SQLDb() *sql.DB {
+	return m.dbMap.Db
+}
+
+func (m *WrappedMap) BorpDB() *borp.DbMap {
+	return m.dbMap
+}
+
+func (m *WrappedMap) TableFor(t reflect.Type, checkPK bool) (*borp.TableMap, error) {
+	return m.dbMap.TableFor(t, checkPK)
 }
 
 func (m *WrappedMap) Get(ctx context.Context, holder interface{}, keys ...interface{}) (interface{}, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.Get(ctx, holder, keys...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.Get(ctx, holder, keys...)
 }
 
 func (m *WrappedMap) Insert(ctx context.Context, list ...interface{}) error {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.Insert(ctx, list...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.Insert(ctx, list...)
 }
 
 func (m *WrappedMap) Update(ctx context.Context, list ...interface{}) (int64, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.Update(ctx, list...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.Update(ctx, list...)
 }
 
 func (m *WrappedMap) Delete(ctx context.Context, list ...interface{}) (int64, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.Delete(ctx, list...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.Delete(ctx, list...)
 }
 
 func (m *WrappedMap) Select(ctx context.Context, holder interface{}, query string, args ...interface{}) ([]interface{}, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.Select(ctx, holder, query, args...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.Select(ctx, holder, query, args...)
 }
 
 func (m *WrappedMap) SelectOne(ctx context.Context, holder interface{}, query string, args ...interface{}) error {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.SelectOne(ctx, holder, query, args...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.SelectOne(ctx, holder, query, args...)
+}
+
+func (m *WrappedMap) SelectNullInt(ctx context.Context, query string, args ...interface{}) (sql.NullInt64, error) {
+	return WrappedExecutor{sqlExecutor: m.dbMap}.SelectNullInt(ctx, query, args...)
 }
 
 func (m *WrappedMap) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.QueryContext(ctx, query, args...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.QueryContext(ctx, query, args...)
+}
+
+func (m *WrappedMap) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
+	return WrappedExecutor{sqlExecutor: m.dbMap}.QueryRowContext(ctx, query, args...)
+}
+
+func (m *WrappedMap) SelectStr(ctx context.Context, query string, args ...interface{}) (string, error) {
+	return WrappedExecutor{sqlExecutor: m.dbMap}.SelectStr(ctx, query, args...)
 }
 
 func (m *WrappedMap) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
-	return WrappedExecutor{SqlExecutor: m.DbMap}.ExecContext(ctx, query, args...)
+	return WrappedExecutor{sqlExecutor: m.dbMap}.ExecContext(ctx, query, args...)
 }
 
 func (m *WrappedMap) BeginTx(ctx context.Context) (Transaction, error) {
-	tx, err := m.DbMap.BeginTx(ctx)
+	tx, err := m.dbMap.BeginTx(ctx)
 	if err != nil {
 		return tx, ErrDatabaseOp{
 			Op:  "begin transaction",
 			Err: err,
 		}
 	}
 	return WrappedTransaction{
-		Transaction: tx,
+		transaction: tx,
 	}, err
 }
 
 // WrappedTransaction wraps a *borp.Transaction such that its major functions
 // wrap error results in ErrDatabaseOp instances before returning them to the
 // caller.
 type WrappedTransaction struct {
-	*borp.Transaction
+	transaction *borp.Transaction
 }
 
 func (tx WrappedTransaction) Commit() error {
-	return tx.Transaction.Commit()
+	return tx.transaction.Commit()
 }
 
 func (tx WrappedTransaction) Rollback() error {
-	return tx.Transaction.Rollback()
+	return tx.transaction.Rollback()
 }
 
 func (tx WrappedTransaction) Get(ctx context.Context, holder interface{}, keys ...interface{}) (interface{}, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).Get(ctx, holder, keys...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).Get(ctx, holder, keys...)
 }
 
 func (tx WrappedTransaction) Insert(ctx context.Context, list ...interface{}) error {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).Insert(ctx, list...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).Insert(ctx, list...)
 }
 
 func (tx WrappedTransaction) Update(ctx context.Context, list ...interface{}) (int64, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).Update(ctx, list...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).Update(ctx, list...)
 }
 
 func (tx WrappedTransaction) Delete(ctx context.Context, list ...interface{}) (int64, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).Delete(ctx, list...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).Delete(ctx, list...)
 }
 
 func (tx WrappedTransaction) Select(ctx context.Context, holder interface{}, query string, args ...interface{}) ([]interface{}, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).Select(ctx, holder, query, args...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).Select(ctx, holder, query, args...)
 }
 
 func (tx WrappedTransaction) SelectOne(ctx context.Context, holder interface{}, query string, args ...interface{}) error {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).SelectOne(ctx, holder, query, args...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).SelectOne(ctx, holder, query, args...)
 }
 
 func (tx WrappedTransaction) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).QueryContext(ctx, query, args...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).QueryContext(ctx, query, args...)
 }
 
 func (tx WrappedTransaction) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
-	return (WrappedExecutor{SqlExecutor: tx.Transaction}).ExecContext(ctx, query, args...)
+	return (WrappedExecutor{sqlExecutor: tx.transaction}).ExecContext(ctx, query, args...)
 }
 
 // WrappedExecutor wraps a borp.SqlExecutor such that its major functions
 // wrap error results in ErrDatabaseOp instances before returning them to the
 // caller.
 type WrappedExecutor struct {
-	borp.SqlExecutor
+	sqlExecutor borp.SqlExecutor
 }
 
 func errForOp(operation string, err error, list []interface{}) ErrDatabaseOp {
@@ -196,55 +225,77 @@ func errForQuery(query, operation string, err error, list []interface{}) ErrData
 }
 
 func (we WrappedExecutor) Get(ctx context.Context, holder interface{}, keys ...interface{}) (interface{}, error) {
-	res, err := we.SqlExecutor.Get(ctx, holder, keys...)
+	res, err := we.sqlExecutor.Get(ctx, holder, keys...)
 	if err != nil {
 		return res, errForOp("get", err, []interface{}{holder})
 	}
 	return res, err
 }
 
 func (we WrappedExecutor) Insert(ctx context.Context, list ...interface{}) error {
-	err := we.SqlExecutor.Insert(ctx, list...)
+	err := we.sqlExecutor.Insert(ctx, list...)
 	if err != nil {
 		return errForOp("insert", err, list)
 	}
 	return nil
 }
 
 func (we WrappedExecutor) Update(ctx context.Context, list ...interface{}) (int64, error) {
-	updatedRows, err := we.SqlExecutor.Update(ctx, list...)
+	updatedRows, err := we.sqlExecutor.Update(ctx, list...)
 	if err != nil {
 		return updatedRows, errForOp("update", err, list)
 	}
 	return updatedRows, err
 }
 
 func (we WrappedExecutor) Delete(ctx context.Context, list ...interface{}) (int64, error) {
-	deletedRows, err := we.SqlExecutor.Delete(ctx, list...)
+	deletedRows, err := we.sqlExecutor.Delete(ctx, list...)
 	if err != nil {
 		return deletedRows, errForOp("delete", err, list)
 	}
 	return deletedRows, err
 }
 
 func (we WrappedExecutor) Select(ctx context.Context, holder interface{}, query string, args ...interface{}) ([]interface{}, error) {
-	result, err := we.SqlExecutor.Select(ctx, holder, query, args...)
+	result, err := we.sqlExecutor.Select(ctx, holder, query, args...)
 	if err != nil {
 		return result, errForQuery(query, "select", err, []interface{}{holder})
 	}
 	return result, err
 }
 
 func (we WrappedExecutor) SelectOne(ctx context.Context, holder interface{}, query string, args ...interface{}) error {
-	err := we.SqlExecutor.SelectOne(ctx, holder, query, args...)
+	err := we.sqlExecutor.SelectOne(ctx, holder, query, args...)
 	if err != nil {
 		return errForQuery(query, "select one", err, []interface{}{holder})
 	}
 	return nil
 }
 
+func (we WrappedExecutor) SelectNullInt(ctx context.Context, query string, args ...interface{}) (sql.NullInt64, error) {
+	rows, err := we.sqlExecutor.SelectNullInt(ctx, query, args...)
+	if err != nil {
+		return sql.NullInt64{}, errForQuery(query, "select", err, nil)
+	}
+	return rows, nil
+}
+
+func (we WrappedExecutor) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
+	// Note: we can't do error wrapping here because the error is passed via the `*sql.Row`
+	// object, and we can't produce a `*sql.Row` object with a custom error because it is unexported.
+	return we.sqlExecutor.QueryRowContext(ctx, query, args...)
+}
+
+func (we WrappedExecutor) SelectStr(ctx context.Context, query string, args ...interface{}) (string, error) {
+	str, err := we.sqlExecutor.SelectStr(ctx, query, args...)
+	if err != nil {
+		return "", errForQuery(query, "select", err, nil)
+	}
+	return str, nil
+}
+
 func (we WrappedExecutor) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
-	rows, err := we.SqlExecutor.QueryContext(ctx, query, args...)
+	rows, err := we.sqlExecutor.QueryContext(ctx, query, args...)
 	if err != nil {
 		return nil, errForQuery(query, "select", err, nil)
 	}
@@ -288,7 +339,7 @@ func tableFromQuery(query string) string {
 }
 
 func (we WrappedExecutor) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
-	res, err := we.SqlExecutor.ExecContext(ctx, query, args...)
+	res, err := we.sqlExecutor.ExecContext(ctx, query, args...)
 	if err != nil {
 		return res, errForQuery(query, "exec", err, args)
 	}

db/map_test.go

@@ -240,7 +240,7 @@ func testDbMap(t *testing.T) *WrappedMap {
 	// NOTE(@cpu): We avoid giving a sa.BoulderTypeConverter to the DbMap field to
 	// avoid the cyclic dep. We don't need to convert any types in the db tests.
 	dbMap := &borp.DbMap{Db: dbConn, Dialect: dialect, TypeConverter: nil}
-	return &WrappedMap{DbMap: dbMap}
+	return &WrappedMap{dbMap: dbMap}
 }
 
 func TestWrappedMap(t *testing.T) {

sa/database.go

@@ -82,7 +82,7 @@ func InitWrappedDb(config cmd.DBConfig, scope prometheus.Registerer, logger blog
 	}
 
 	if scope != nil {
-		err = initDBMetrics(dbMap.Db, scope, settings, addr, user)
+		err = initDBMetrics(dbMap.SQLDb(), scope, settings, addr, user)
 		if err != nil {
 			return nil, fmt.Errorf("while initializing metrics: %w", err)
 		}
@@ -170,7 +170,7 @@ func newDbMapFromMySQLConfig(config *mysql.Config, settings DbSettings) (*boulde
 	dbmap := &borp.DbMap{Db: db, Dialect: dialect, TypeConverter: BoulderTypeConverter{}}
 
 	initTables(dbmap)
-	return &boulderDB.WrappedMap{DbMap: dbmap}, nil
+	return boulderDB.NewWrappedMap(dbmap), nil
 }
 
 // adjustMySQLConfig sets certain flags that we want on every connection.
@@ -241,7 +241,7 @@ func adjustMySQLConfig(conf *mysql.Config) error {
 
 // SetSQLDebug enables borp SQL-level Debugging
 func SetSQLDebug(dbMap *boulderDB.WrappedMap, log blog.Logger) {
-	dbMap.TraceOn("SQL: ", &SQLLogger{log})
+	dbMap.BorpDB().TraceOn("SQL: ", &SQLLogger{log})
 }
 
 // SQLLogger adapts the Boulder Logger to a format borp can use.