Variadic methods.

Author: mdwhatcott

contracts.go

@@ -25,9 +25,9 @@ type (
 	// Handle is a high level approach to common database operations, where each operation implements either
 	// the Query or Script interface.
 	Handle interface {
-		Execute(ctx context.Context, script Script) error
-		Populate(ctx context.Context, query Query) error
-		PopulateRow(ctx context.Context, query Query) error
+		Execute(context.Context, ...Script) error
+		Populate(context.Context, ...Query) error
+		PopulateRow(context.Context, ...Query) error
 	}
 
 	// Script represents SQL statements that aren't expected to provide rows as a result.

db.go

@@ -60,81 +60,92 @@ func checksum(x []byte) (hash uint64) {
 	return h.Sum64()
 }
 
-func (this *defaultHandle) Execute(ctx context.Context, script Script) (err error) {
+func (this *defaultHandle) Execute(ctx context.Context, scripts ...Script) (err error) {
 	defer func() { err = normalizeErr(err) }()
-	statements := script.Statements()
-	parameters := script.Parameters()
-	placeholderCount := strings.Count(statements, "?")
-	if placeholderCount != len(parameters) {
-		return fmt.Errorf("%w: Expected: %d, received %d", ErrParameterCountMismatch, placeholderCount, len(parameters))
+	for _, script := range scripts {
+		statements := script.Statements()
+		parameters := script.Parameters()
+		placeholderCount := strings.Count(statements, "?")
+		if placeholderCount != len(parameters) {
+			return fmt.Errorf("%w: Expected: %d, received %d", ErrParameterCountMismatch, placeholderCount, len(parameters))
+		}
+		for statement, params := range interleaveParameters(statements, parameters...) {
+			prepared, err := this.prepare(ctx, statement)
+			if err != nil {
+				return err
+			}
+			var result sql.Result
+			if prepared != nil {
+				result, err = prepared.ExecContext(ctx, params...)
+			} else {
+				result, err = this.pool.ExecContext(ctx, statement, params...)
+			}
+			if err != nil {
+				return err
+			}
+			if rows, ok := script.(RowsAffected); ok {
+				if affected, err := result.RowsAffected(); err == nil {
+					rows.RowsAffected(uint64(affected))
+				}
+			}
+		}
 	}
-	for statement, params := range interleaveParameters(statements, parameters...) {
+	return nil
+}
+func (this *defaultHandle) Populate(ctx context.Context, queries ...Query) (err error) {
+	defer func() { err = normalizeErr(err) }()
+	for _, query := range queries {
+		statement := query.Statement()
 		prepared, err := this.prepare(ctx, statement)
 		if err != nil {
 			return err
 		}
-		var result sql.Result
+		parameters := query.Parameters()
+		var rows *sql.Rows
 		if prepared != nil {
-			result, err = prepared.ExecContext(ctx, params...)
+			rows, err = prepared.QueryContext(ctx, parameters...)
 		} else {
-			result, err = this.pool.ExecContext(ctx, statement, params...)
+			rows, err = this.pool.QueryContext(ctx, statement, parameters...)
 		}
 		if err != nil {
 			return err
 		}
-		if rows, ok := script.(RowsAffected); ok {
-			if affected, err := result.RowsAffected(); err == nil {
-				rows.RowsAffected(uint64(affected))
+		for rows.Next() {
+			err = query.Scan(rows)
+			if err != nil {
+				_ = rows.Close()
+				return err
 			}
 		}
+		_ = rows.Close()
 	}
 	return nil
 }
-func (this *defaultHandle) Populate(ctx context.Context, query Query) (err error) {
+func (this *defaultHandle) PopulateRow(ctx context.Context, queries ...Query) (err error) {
 	defer func() { err = normalizeErr(err) }()
-	statement := query.Statement()
-	prepared, err := this.prepare(ctx, statement)
-	if err != nil {
-		return err
-	}
-	parameters := query.Parameters()
-	var rows *sql.Rows
-	if prepared != nil {
-		rows, err = prepared.QueryContext(ctx, parameters...)
-	} else {
-		rows, err = this.pool.QueryContext(ctx, statement, parameters...)
-	}
-	if err != nil {
-		return err
-	}
-	defer func() { _ = rows.Close() }()
-	for rows.Next() {
-		err = query.Scan(rows)
+	for _, query := range queries {
+		statement := query.Statement()
+		prepared, err := this.prepare(ctx, statement)
 		if err != nil {
 			return err
 		}
-	}
-	return rows.Err()
-}
-func (this *defaultHandle) PopulateRow(ctx context.Context, query Query) (err error) {
-	defer func() { err = normalizeErr(err) }()
-	statement := query.Statement()
-	prepared, err := this.prepare(ctx, statement)
-	if err != nil {
+		parameters := query.Parameters()
+		var row *sql.Row
+		if prepared != nil {
+			row = prepared.QueryRowContext(ctx, parameters...)
+		} else {
+			row = this.pool.QueryRowContext(ctx, statement, parameters...)
+		}
+		err = query.Scan(row)
+		if err == nil {
+			continue
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			continue
+		}
 		return err
 	}
-	parameters := query.Parameters()
-	var row *sql.Row
-	if prepared != nil {
-		row = prepared.QueryRowContext(ctx, parameters...)
-	} else {
-		row = this.pool.QueryRowContext(ctx, statement, parameters...)
-	}
-	err = query.Scan(row)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil
-	}
-	return err
+	return nil
 }
 
 // interleaveParameters splits the statements (on ';') and yields each with its corresponding parameters.