v3

Implement the spirit of previous versions in a single file with just a
few simple functions. Adds inherent support for prepared statements, as
well as QueryRowContext.

It is very plausible that this module, which is now less than 100 lines
of code, is a good candidate for copy-paste installation.

Author: mdwhatcott

go.mod

@@ -1,3 +1,3 @@
-module github.com/smarty/sqldb/v2
+module github.com/smarty/sqldb/v3
 
 go 1.18

sqldb.go

@@ -0,0 +1,92 @@
+package sqldb
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"runtime/debug"
+	"strings"
+)
+
+var ErrArgumentCountMismatch = errors.New("the number of arguments supplied does not match the statement")
+
+type Binder func(Scanner) error
+
+type Scanner interface {
+	Scan(...any) error
+}
+
+// DBTx is either a *sql.DB or a *sql.Tx
+type DBTx interface {
+	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
+	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
+	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
+}
+
+// BindAll receives the *sql.Rows + error from the QueryContext method of either
+// a *sql.DB, a *sql.Tx, or a *sql.Stmt, as well as a binder callback, to be called
+// for each record, which gives the caller the opportunity to scan and aggregate values.
+func BindAll(rows *sql.Rows, err error, binder Binder) error {
+	if err != nil {
+		return normalize(err)
+	}
+	defer func() { _ = rows.Close() }()
+	for rows.Next() {
+		err = binder(rows)
+		if err != nil {
+			return normalize(err)
+		}
+	}
+	return nil
+}
+
+// ExecuteStatements receives a *sql.DB or *sql.Tx as well as one or more SQL statements (separated by ';')
+// and executes each one with the arguments corresponding to that statement.
+func ExecuteStatements(ctx context.Context, db DBTx, statements string, args ...any) (uint64, error) {
+	placeholderCount := strings.Count(statements, "?")
+	if placeholderCount != len(args) {
+		return 0, fmt.Errorf("%w: Expected: %d, received %d", ErrArgumentCountMismatch, placeholderCount, len(args))
+	}
+	var count uint64
+	index := 0
+	for _, statement := range strings.Split(statements, ";") {
+		if len(strings.TrimSpace(statement)) == 0 {
+			continue
+		}
+		statement += ";" // terminate the statement
+		indexOffset := strings.Count(statement, "?")
+		result, err := db.ExecContext(ctx, statement, args[index:index+indexOffset]...)
+		rows, err := RowsAffected(result, err)
+		if err != nil {
+			return 0, err // already normalized
+		}
+		count += rows
+		index += indexOffset
+	}
+	return count, nil
+}
+
+// RowsAffected returns the rows affected from a sql.Result. This is generally only needed
+// by external callers when dealing with the result of a prepared statement.
+func RowsAffected(result sql.Result, err error) (uint64, error) {
+	if err != nil {
+		return 0, normalize(err)
+	}
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return 0, normalize(err)
+	}
+	return uint64(rows), nil
+}
+func normalize(err error) error {
+	if err == nil {
+		return nil
+	}
+	err = fmt.Errorf("%w\nStack Trace:\n%s", err, string(debug.Stack()))
+	if strings.Contains(err.Error(), "operation was canceled") {
+		return fmt.Errorf("%w: %w", context.Canceled, err)
+	}
+	return err
+}

sqldb_test.go

@@ -0,0 +1,79 @@
+package sqldb_test
+
+import (
+	"context"
+	"time"
+
+	"github.com/smarty/sqldb/v3"
+)
+
+// Business Event:
+type FooEstablished struct {
+	Timestamp time.Time
+	FooID     uint64
+}
+
+// Storage Operation:
+type LoadFooName struct {
+	FooID  uint64
+	Result struct {
+		FooID   uint64
+		FooName string
+	}
+}
+
+type Mapper struct {
+	db sqldb.DBTx
+}
+
+func (this Mapper) fooEstablished(ctx context.Context, operation FooEstablished) (uint64, error) {
+	return sqldb.ExecuteStatements(ctx, this.db, `
+		INSERT
+		  INTO Foos
+		       ( foo_id, created, foo_name )
+		VALUES ( ?, ?, '' )
+		    ON DUPLICATE KEY 
+		UPDATE created = created;`,
+		operation.FooID, operation.Timestamp,
+	)
+}
+func (this Mapper) fooEstablished_Prepared(ctx context.Context, operation FooEstablished) (uint64, error) {
+	statement, err := this.db.PrepareContext(ctx, `
+		INSERT
+		  INTO Foos
+		       ( foo_id, created, foo_name )
+		VALUES ( ?, ?, '' )
+		    ON DUPLICATE KEY 
+		UPDATE created = created;`,
+	)
+	if err != nil {
+		return 0, err
+	}
+	return sqldb.RowsAffected(statement.ExecContext(ctx, operation.FooID, operation.Timestamp))
+}
+
+func (this Mapper) loadFooName(ctx context.Context, operation *LoadFooName) error {
+	rows, err := this.db.QueryContext(ctx, `
+		SELECT foo_id, foo_name
+		  FROM Foos 
+		 WHERE foo_id = ?;`,
+		operation.FooID,
+	)
+	return sqldb.BindAll(rows, err, func(source sqldb.Scanner) error {
+		return source.Scan(&operation.Result.FooID, &operation.Result.FooName)
+	})
+}
+func (this Mapper) loadFooName_Prepared(ctx context.Context, operation *LoadFooName) error {
+	statement, err := this.db.PrepareContext(ctx, `
+		SELECT foo_id, foo_name
+		  FROM Foos 
+		 WHERE foo_id = ?;`,
+	)
+	if err != nil {
+		return err
+	}
+	rows, err := statement.QueryContext(ctx, operation.FooID)
+	return sqldb.BindAll(rows, err, func(source sqldb.Scanner) error {
+		return source.Scan(&operation.Result.FooID, &operation.Result.FooName)
+	})
+}