Remove pkg/errors in favor of std lib (#373)

mfridman · web-flow · commit f3d569f61bc6 · 2022-06-22T21:36:07.000-04:00
diff --git a/create.go b/create.go
@@ -7,8 +7,6 @@ import (
 	"path/filepath"
 	"text/template"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 type tmplVars struct {
@@ -61,12 +59,12 @@ func CreateWithTemplate(db *sql.DB, dir string, tmpl *template.Template, name, m
 
 	path := filepath.Join(dir, filename)
 	if _, err := os.Stat(path); !os.IsNotExist(err) {
-		return errors.Wrap(err, "failed to create migration file")
+		return fmt.Errorf("failed to create migration file: %w", err)
 	}
 
 	f, err := os.Create(path)
 	if err != nil {
-		return errors.Wrap(err, "failed to create migration file")
+		return fmt.Errorf("failed to create migration file: %w", err)
 	}
 	defer f.Close()
 
@@ -75,7 +73,7 @@ func CreateWithTemplate(db *sql.DB, dir string, tmpl *template.Template, name, m
 		CamelName: camelCase(name),
 	}
 	if err := tmpl.Execute(f, vars); err != nil {
-		return errors.Wrap(err, "failed to execute tmpl")
+		return fmt.Errorf("failed to execute tmpl: %w", err)
 	}
 
 	log.Printf("Created new file: %s\n", f.Name())
diff --git a/go.mod b/go.mod
@@ -9,7 +9,6 @@ require (
 	github.com/go-sql-driver/mysql v1.6.0
 	github.com/lib/pq v1.10.6
 	github.com/ory/dockertest/v3 v3.9.1
-	github.com/pkg/errors v0.9.1
 	github.com/ziutek/mymysql v1.5.4
 	modernc.org/sqlite v1.17.3
 )
@@ -39,6 +38,7 @@ require (
 	github.com/opencontainers/runc v1.1.2 // indirect
 	github.com/paulmach/orb v0.7.1 // indirect
 	github.com/pierrec/lz4/v4 v4.1.15 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
 	github.com/shopspring/decimal v1.3.1 // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
diff --git a/migrate.go b/migrate.go
@@ -2,14 +2,13 @@ package goose
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"io/fs"
 	"path"
 	"runtime"
 	"sort"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 var (
@@ -256,7 +255,7 @@ func EnsureDBVersion(db *sql.DB) (int64, error) {
 	for rows.Next() {
 		var row MigrationRecord
 		if err = rows.Scan(&row.VersionID, &row.IsApplied); err != nil {
-			return 0, errors.Wrap(err, "failed to scan row")
+			return 0, fmt.Errorf("failed to scan row: %w", err)
 		}
 
 		// have we already marked this version to be skipped?
@@ -281,7 +280,7 @@ func EnsureDBVersion(db *sql.DB) (int64, error) {
 		toSkip = append(toSkip, row.VersionID)
 	}
 	if err := rows.Err(); err != nil {
-		return 0, errors.Wrap(err, "failed to get next row")
+		return 0, fmt.Errorf("failed to get next row: %w", err)
 	}
 
 	return 0, ErrNoNextVersion
diff --git a/migration.go b/migration.go
@@ -2,13 +2,12 @@ package goose
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 // MigrationRecord struct.
@@ -55,17 +54,17 @@ func (m *Migration) run(db *sql.DB, direction bool) error {
 	case ".sql":
 		f, err := baseFS.Open(m.Source)
 		if err != nil {
-			return errors.Wrapf(err, "ERROR %v: failed to open SQL migration file", filepath.Base(m.Source))
+			return fmt.Errorf("ERROR %v: failed to open SQL migration file: %w", filepath.Base(m.Source), err)
 		}
 		defer f.Close()
 
 		statements, useTx, err := parseSQLMigration(f, direction)
 		if err != nil {
-			return errors.Wrapf(err, "ERROR %v: failed to parse SQL migration file", filepath.Base(m.Source))
+			return fmt.Errorf("ERROR %v: failed to parse SQL migration file: %w", filepath.Base(m.Source), err)
 		}
 
 		if err := runSQLMigration(db, statements, useTx, m.Version, direction, m.noVersioning); err != nil {
-			return errors.Wrapf(err, "ERROR %v: failed to run SQL migration", filepath.Base(m.Source))
+			return fmt.Errorf("ERROR %v: failed to run SQL migration: %w", filepath.Base(m.Source), err)
 		}
 
 		if len(statements) > 0 {
@@ -76,11 +75,11 @@ func (m *Migration) run(db *sql.DB, direction bool) error {
 
 	case ".go":
 		if !m.Registered {
-			return errors.Errorf("ERROR %v: failed to run Go migration: Go functions must be registered and built into a custom binary (see https://github.com/pressly/goose/tree/master/examples/go-migrations)", m.Source)
+			return fmt.Errorf("ERROR %v: failed to run Go migration: Go functions must be registered and built into a custom binary (see https://github.com/pressly/goose/tree/master/examples/go-migrations)", m.Source)
 		}
 		tx, err := db.Begin()
 		if err != nil {
-			return errors.Wrap(err, "ERROR failed to begin transaction")
+			return fmt.Errorf("ERROR failed to begin transaction: %w", err)
 		}
 
 		fn := m.UpFn
@@ -92,25 +91,25 @@ func (m *Migration) run(db *sql.DB, direction bool) error {
 			// Run Go migration function.
 			if err := fn(tx); err != nil {
 				tx.Rollback()
-				return errors.Wrapf(err, "ERROR %v: failed to run Go migration function %T", filepath.Base(m.Source), fn)
+				return fmt.Errorf("ERROR %v: failed to run Go migration function %T: %w", filepath.Base(m.Source), fn, err)
 			}
 		}
 		if !m.noVersioning {
 			if direction {
 				if _, err := tx.Exec(GetDialect().insertVersionSQL(), m.Version, direction); err != nil {
 					tx.Rollback()
-					return errors.Wrap(err, "ERROR failed to execute transaction")
+					return fmt.Errorf("ERROR failed to execute transaction: %w", err)
 				}
 			} else {
 				if _, err := tx.Exec(GetDialect().deleteVersionSQL(), m.Version); err != nil {
 					tx.Rollback()
-					return errors.Wrap(err, "ERROR failed to execute transaction")
+					return fmt.Errorf("ERROR failed to execute transaction: %w", err)
 				}
 			}
 		}
 
 		if err := tx.Commit(); err != nil {
-			return errors.Wrap(err, "ERROR failed to commit transaction")
+			return fmt.Errorf("ERROR failed to commit transaction: %w", err)
 		}
 
 		if fn != nil {
diff --git a/migration_sql.go b/migration_sql.go
@@ -2,10 +2,9 @@ package goose
 
 import (
 	"database/sql"
+	"fmt"
 	"regexp"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 // Run a migration specified in raw SQL.
@@ -24,15 +23,15 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc
 
 		tx, err := db.Begin()
 		if err != nil {
-			return errors.Wrap(err, "failed to begin transaction")
+			return fmt.Errorf("failed to begin transaction: %w", err)
 		}
 
 		for _, query := range statements {
 			verboseInfo("Executing statement: %s\n", clearStatement(query))
 			if err = execQuery(tx.Exec, query); err != nil {
 				verboseInfo("Rollback transaction")
 				tx.Rollback()
-				return errors.Wrapf(err, "failed to execute SQL query %q", clearStatement(query))
+				return fmt.Errorf("failed to execute SQL query %q: %w", clearStatement(query), err)
 			}
 		}
 
@@ -41,20 +40,20 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc
 				if err := execQuery(tx.Exec, GetDialect().insertVersionSQL(), v, direction); err != nil {
 					verboseInfo("Rollback transaction")
 					tx.Rollback()
-					return errors.Wrap(err, "failed to insert new goose version")
+					return fmt.Errorf("failed to insert new goose version: %w", err)
 				}
 			} else {
 				if err := execQuery(tx.Exec, GetDialect().deleteVersionSQL(), v); err != nil {
 					verboseInfo("Rollback transaction")
 					tx.Rollback()
-					return errors.Wrap(err, "failed to delete goose version")
+					return fmt.Errorf("failed to delete goose version: %w", err)
 				}
 			}
 		}
 
 		verboseInfo("Commit transaction")
 		if err := tx.Commit(); err != nil {
-			return errors.Wrap(err, "failed to commit transaction")
+			return fmt.Errorf("failed to commit transaction: %w", err)
 		}
 
 		return nil
@@ -64,17 +63,17 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc
 	for _, query := range statements {
 		verboseInfo("Executing statement: %s", clearStatement(query))
 		if err := execQuery(db.Exec, query); err != nil {
-			return errors.Wrapf(err, "failed to execute SQL query %q", clearStatement(query))
+			return fmt.Errorf("failed to execute SQL query %q: %w", clearStatement(query), err)
 		}
 	}
 	if !noVersioning {
 		if direction {
 			if err := execQuery(db.Exec, GetDialect().insertVersionSQL(), v, direction); err != nil {
-				return errors.Wrap(err, "failed to insert new goose version")
+				return fmt.Errorf("failed to insert new goose version: %w", err)
 			}
 		} else {
 			if err := execQuery(db.Exec, GetDialect().deleteVersionSQL(), v); err != nil {
-				return errors.Wrap(err, "failed to delete goose version")
+				return fmt.Errorf("failed to delete goose version: %w", err)
 			}
 		}
 	}
diff --git a/reset.go b/reset.go
@@ -2,9 +2,8 @@ package goose
 
 import (
 	"database/sql"
+	"fmt"
 	"sort"
-
-	"github.com/pkg/errors"
 )
 
 // Reset rolls back all migrations
@@ -15,15 +14,15 @@ func Reset(db *sql.DB, dir string, opts ...OptionsFunc) error {
 	}
 	migrations, err := CollectMigrations(dir, minVersion, maxVersion)
 	if err != nil {
-		return errors.Wrap(err, "failed to collect migrations")
+		return fmt.Errorf("failed to collect migrations: %w", err)
 	}
 	if option.noVersioning {
 		return DownTo(db, dir, minVersion, opts...)
 	}
 
 	statuses, err := dbMigrationsStatus(db)
 	if err != nil {
-		return errors.Wrap(err, "failed to get status of migrations")
+		return fmt.Errorf("failed to get status of migrations: %w", err)
 	}
 	sort.Sort(sort.Reverse(migrations))
 
@@ -32,7 +31,7 @@ func Reset(db *sql.DB, dir string, opts ...OptionsFunc) error {
 			continue
 		}
 		if err = migration.Down(db); err != nil {
-			return errors.Wrap(err, "failed to db-down")
+			return fmt.Errorf("failed to db-down: %w", err)
 		}
 	}
 
@@ -54,7 +53,7 @@ func dbMigrationsStatus(db *sql.DB) (map[int64]bool, error) {
 	for rows.Next() {
 		var row MigrationRecord
 		if err = rows.Scan(&row.VersionID, &row.IsApplied); err != nil {
-			return nil, errors.Wrap(err, "failed to scan row")
+			return nil, fmt.Errorf("failed to scan row: %w", err)
 		}
 
 		if _, ok := result[row.VersionID]; ok {
diff --git a/sql_parser.go b/sql_parser.go
@@ -3,12 +3,13 @@ package goose
 import (
 	"bufio"
 	"bytes"
+	"fmt"
 	"io"
 	"regexp"
 	"strings"
 	"sync"
 
-	"github.com/pkg/errors"
+	"errors"
 )
 
 type parserState int
@@ -79,7 +80,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 				case start:
 					stateMachine.Set(gooseUp)
 				default:
-					return nil, false, errors.Errorf("duplicate '-- +goose Up' annotations; stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
+					return nil, false, fmt.Errorf("duplicate '-- +goose Up' annotations; stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
 				}
 				continue
 
@@ -88,7 +89,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 				case gooseUp, gooseStatementEndUp:
 					stateMachine.Set(gooseDown)
 				default:
-					return nil, false, errors.Errorf("must start with '-- +goose Up' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
+					return nil, false, fmt.Errorf("must start with '-- +goose Up' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
 				}
 				continue
 
@@ -99,7 +100,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 				case gooseDown, gooseStatementEndDown:
 					stateMachine.Set(gooseStatementBeginDown)
 				default:
-					return nil, false, errors.Errorf("'-- +goose StatementBegin' must be defined after '-- +goose Up' or '-- +goose Down' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
+					return nil, false, fmt.Errorf("'-- +goose StatementBegin' must be defined after '-- +goose Up' or '-- +goose Down' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)
 				}
 				continue
 
@@ -132,7 +133,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 
 		// Write SQL line to a buffer.
 		if _, err := buf.WriteString(line + "\n"); err != nil {
-			return nil, false, errors.Wrap(err, "failed to write to buf")
+			return nil, false, fmt.Errorf("failed to write to buf: %w", err)
 		}
 
 		// Read SQL body one by line, if we're in the right direction.
@@ -154,7 +155,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 				continue
 			}
 		default:
-			return nil, false, errors.Errorf("failed to parse migration: unexpected state %q on line %q, see https://github.com/pressly/goose#sql-migrations", stateMachine, line)
+			return nil, false, fmt.Errorf("failed to parse migration: unexpected state %q on line %q, see https://github.com/pressly/goose#sql-migrations", stateMachine, line)
 		}
 
 		switch stateMachine.Get() {
@@ -183,7 +184,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 		}
 	}
 	if err := scanner.Err(); err != nil {
-		return nil, false, errors.Wrap(err, "failed to scan migration")
+		return nil, false, fmt.Errorf("failed to scan migration: %w", err)
 	}
 	// EOF
 
@@ -195,7 +196,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,
 	}
 
 	if bufferRemaining := strings.TrimSpace(buf.String()); len(bufferRemaining) > 0 {
-		return nil, false, errors.Errorf("failed to parse migration: state %q, direction: %v: unexpected unfinished SQL query: %q: missing semicolon?", stateMachine, direction, bufferRemaining)
+		return nil, false, fmt.Errorf("failed to parse migration: state %q, direction: %v: unexpected unfinished SQL query: %q: missing semicolon?", stateMachine, direction, bufferRemaining)
 	}
 
 	return stmts, useTx, nil
diff --git a/sql_parser_test.go b/sql_parser_test.go
@@ -1,11 +1,10 @@
 package goose
 
 import (
+	"fmt"
 	"os"
 	"strings"
 	"testing"
-
-	"github.com/pkg/errors"
 )
 
 func TestSemicolons(t *testing.T) {
@@ -58,7 +57,7 @@ func TestSplitStatements(t *testing.T) {
 		// up
 		stmts, _, err := parseSQLMigration(strings.NewReader(test.sql), true)
 		if err != nil {
-			t.Error(errors.Wrapf(err, "tt[%v] unexpected error", i))
+			t.Error(fmt.Errorf("tt[%v] unexpected error: %w", i, err))
 		}
 		if len(stmts) != test.up {
 			t.Errorf("tt[%v] incorrect number of up stmts. got %v (%+v), want %v", i, len(stmts), stmts, test.up)
@@ -67,7 +66,7 @@ func TestSplitStatements(t *testing.T) {
 		// down
 		stmts, _, err = parseSQLMigration(strings.NewReader(test.sql), false)
 		if err != nil {
-			t.Error(errors.Wrapf(err, "tt[%v] unexpected error", i))
+			t.Error(fmt.Errorf("tt[%v] unexpected error: %w", i, err))
 		}
 		if len(stmts) != test.down {
 			t.Errorf("tt[%v] incorrect number of down stmts. got %v (%+v), want %v", i, len(stmts), stmts, test.down)
diff --git a/status.go b/status.go
diff --git a/version.go b/version.go

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,6 @@ import (`
`7`	`7`	`"path/filepath"`
`8`	`8`	`"text/template"`
`9`	`9`	`"time"`
`10`		`-`
`11`		`- "github.com/pkg/errors"`
`12`	`10`	`)`
`13`	`11`
`14`	`12`	`type tmplVars struct {`
`@@ -61,12 +59,12 @@ func CreateWithTemplate(db sql.DB, dir string, tmpl template.Template, name, m`
`61`	`59`
`62`	`60`	`path := filepath.Join(dir, filename)`
`63`	`61`	`if _, err := os.Stat(path); !os.IsNotExist(err) {`
`64`		`- return errors.Wrap(err, "failed to create migration file")`
	`62`	`+ return fmt.Errorf("failed to create migration file: %w", err)`
`65`	`63`	`}`
`66`	`64`
`67`	`65`	`f, err := os.Create(path)`
`68`	`66`	`if err != nil {`
`69`		`- return errors.Wrap(err, "failed to create migration file")`
	`67`	`+ return fmt.Errorf("failed to create migration file: %w", err)`
`70`	`68`	`}`
`71`	`69`	`defer f.Close()`
`72`	`70`
`@@ -75,7 +73,7 @@ func CreateWithTemplate(db sql.DB, dir string, tmpl template.Template, name, m`
`75`	`73`	`CamelName: camelCase(name),`
`76`	`74`	`}`
`77`	`75`	`if err := tmpl.Execute(f, vars); err != nil {`
`78`		`- return errors.Wrap(err, "failed to execute tmpl")`
	`76`	`+ return fmt.Errorf("failed to execute tmpl: %w", err)`
`79`	`77`	`}`
`80`	`78`
`81`	`79`	`log.Printf("Created new file: %s\n", f.Name())`
Original file line number	Diff line number	Diff line change
`@@ -2,13 +2,12 @@ package goose`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"database/sql"`
	`5`	`+ "errors"`
`5`	`6`	`"fmt"`
`6`	`7`	`"path/filepath"`
`7`	`8`	`"strconv"`
`8`	`9`	`"strings"`
`9`	`10`	`"time"`
`10`		`-`
`11`		`- "github.com/pkg/errors"`
`12`	`11`	`)`
`13`	`12`
`14`	`13`	`// MigrationRecord struct.`
`@@ -55,17 +54,17 @@ func (m Migration) run(db sql.DB, direction bool) error {`
`55`	`54`	`case ".sql":`
`56`	`55`	`f, err := baseFS.Open(m.Source)`
`57`	`56`	`if err != nil {`
`58`		`- return errors.Wrapf(err, "ERROR %v: failed to open SQL migration file", filepath.Base(m.Source))`
	`57`	`+ return fmt.Errorf("ERROR %v: failed to open SQL migration file: %w", filepath.Base(m.Source), err)`
`59`	`58`	`}`
`60`	`59`	`defer f.Close()`
`61`	`60`
`62`	`61`	`statements, useTx, err := parseSQLMigration(f, direction)`
`63`	`62`	`if err != nil {`
`64`		`- return errors.Wrapf(err, "ERROR %v: failed to parse SQL migration file", filepath.Base(m.Source))`
	`63`	`+ return fmt.Errorf("ERROR %v: failed to parse SQL migration file: %w", filepath.Base(m.Source), err)`
`65`	`64`	`}`
`66`	`65`
`67`	`66`	`if err := runSQLMigration(db, statements, useTx, m.Version, direction, m.noVersioning); err != nil {`
`68`		`- return errors.Wrapf(err, "ERROR %v: failed to run SQL migration", filepath.Base(m.Source))`
	`67`	`+ return fmt.Errorf("ERROR %v: failed to run SQL migration: %w", filepath.Base(m.Source), err)`
`69`	`68`	`}`
`70`	`69`
`71`	`70`	`if len(statements) > 0 {`
`@@ -76,11 +75,11 @@ func (m Migration) run(db sql.DB, direction bool) error {`
`76`	`75`
`77`	`76`	`case ".go":`
`78`	`77`	`if !m.Registered {`
`79`		`- return errors.Errorf("ERROR %v: failed to run Go migration: Go functions must be registered and built into a custom binary (see https://github.com/pressly/goose/tree/master/examples/go-migrations)", m.Source)`
	`78`	`+ return fmt.Errorf("ERROR %v: failed to run Go migration: Go functions must be registered and built into a custom binary (see https://github.com/pressly/goose/tree/master/examples/go-migrations)", m.Source)`
`80`	`79`	`}`
`81`	`80`	`tx, err := db.Begin()`
`82`	`81`	`if err != nil {`
`83`		`- return errors.Wrap(err, "ERROR failed to begin transaction")`
	`82`	`+ return fmt.Errorf("ERROR failed to begin transaction: %w", err)`
`84`	`83`	`}`
`85`	`84`
`86`	`85`	`fn := m.UpFn`
`@@ -92,25 +91,25 @@ func (m Migration) run(db sql.DB, direction bool) error {`
`92`	`91`	`// Run Go migration function.`
`93`	`92`	`if err := fn(tx); err != nil {`
`94`	`93`	`tx.Rollback()`
`95`		`- return errors.Wrapf(err, "ERROR %v: failed to run Go migration function %T", filepath.Base(m.Source), fn)`
	`94`	`+ return fmt.Errorf("ERROR %v: failed to run Go migration function %T: %w", filepath.Base(m.Source), fn, err)`
`96`	`95`	`}`
`97`	`96`	`}`
`98`	`97`	`if !m.noVersioning {`
`99`	`98`	`if direction {`
`100`	`99`	`if _, err := tx.Exec(GetDialect().insertVersionSQL(), m.Version, direction); err != nil {`
`101`	`100`	`tx.Rollback()`
`102`		`- return errors.Wrap(err, "ERROR failed to execute transaction")`
	`101`	`+ return fmt.Errorf("ERROR failed to execute transaction: %w", err)`
`103`	`102`	`}`
`104`	`103`	`} else {`
`105`	`104`	`if _, err := tx.Exec(GetDialect().deleteVersionSQL(), m.Version); err != nil {`
`106`	`105`	`tx.Rollback()`
`107`		`- return errors.Wrap(err, "ERROR failed to execute transaction")`
	`106`	`+ return fmt.Errorf("ERROR failed to execute transaction: %w", err)`
`108`	`107`	`}`
`109`	`108`	`}`
`110`	`109`	`}`
`111`	`110`
`112`	`111`	`if err := tx.Commit(); err != nil {`
`113`		`- return errors.Wrap(err, "ERROR failed to commit transaction")`
	`112`	`+ return fmt.Errorf("ERROR failed to commit transaction: %w", err)`
`114`	`113`	`}`
`115`	`114`
`116`	`115`	`if fn != nil {`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,9 @@ package goose`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"database/sql"`
	`5`	`+ "fmt"`
`5`	`6`	`"regexp"`
`6`	`7`	`"time"`
`7`		`-`
`8`		`- "github.com/pkg/errors"`
`9`	`8`	`)`
`10`	`9`
`11`	`10`	`// Run a migration specified in raw SQL.`
`@@ -24,15 +23,15 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc`
`24`	`23`
`25`	`24`	`tx, err := db.Begin()`
`26`	`25`	`if err != nil {`
`27`		`- return errors.Wrap(err, "failed to begin transaction")`
	`26`	`+ return fmt.Errorf("failed to begin transaction: %w", err)`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`for _, query := range statements {`
`31`	`30`	`verboseInfo("Executing statement: %s\n", clearStatement(query))`
`32`	`31`	`if err = execQuery(tx.Exec, query); err != nil {`
`33`	`32`	`verboseInfo("Rollback transaction")`
`34`	`33`	`tx.Rollback()`
`35`		`- return errors.Wrapf(err, "failed to execute SQL query %q", clearStatement(query))`
	`34`	`+ return fmt.Errorf("failed to execute SQL query %q: %w", clearStatement(query), err)`
`36`	`35`	`}`
`37`	`36`	`}`
`38`	`37`
`@@ -41,20 +40,20 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc`
`41`	`40`	`if err := execQuery(tx.Exec, GetDialect().insertVersionSQL(), v, direction); err != nil {`
`42`	`41`	`verboseInfo("Rollback transaction")`
`43`	`42`	`tx.Rollback()`
`44`		`- return errors.Wrap(err, "failed to insert new goose version")`
	`43`	`+ return fmt.Errorf("failed to insert new goose version: %w", err)`
`45`	`44`	`}`
`46`	`45`	`} else {`
`47`	`46`	`if err := execQuery(tx.Exec, GetDialect().deleteVersionSQL(), v); err != nil {`
`48`	`47`	`verboseInfo("Rollback transaction")`
`49`	`48`	`tx.Rollback()`
`50`		`- return errors.Wrap(err, "failed to delete goose version")`
	`49`	`+ return fmt.Errorf("failed to delete goose version: %w", err)`
`51`	`50`	`}`
`52`	`51`	`}`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`verboseInfo("Commit transaction")`
`56`	`55`	`if err := tx.Commit(); err != nil {`
`57`		`- return errors.Wrap(err, "failed to commit transaction")`
	`56`	`+ return fmt.Errorf("failed to commit transaction: %w", err)`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`return nil`
`@@ -64,17 +63,17 @@ func runSQLMigration(db *sql.DB, statements []string, useTx bool, v int64, direc`
`64`	`63`	`for _, query := range statements {`
`65`	`64`	`verboseInfo("Executing statement: %s", clearStatement(query))`
`66`	`65`	`if err := execQuery(db.Exec, query); err != nil {`
`67`		`- return errors.Wrapf(err, "failed to execute SQL query %q", clearStatement(query))`
	`66`	`+ return fmt.Errorf("failed to execute SQL query %q: %w", clearStatement(query), err)`
`68`	`67`	`}`
`69`	`68`	`}`
`70`	`69`	`if !noVersioning {`
`71`	`70`	`if direction {`
`72`	`71`	`if err := execQuery(db.Exec, GetDialect().insertVersionSQL(), v, direction); err != nil {`
`73`		`- return errors.Wrap(err, "failed to insert new goose version")`
	`72`	`+ return fmt.Errorf("failed to insert new goose version: %w", err)`
`74`	`73`	`}`
`75`	`74`	`} else {`
`76`	`75`	`if err := execQuery(db.Exec, GetDialect().deleteVersionSQL(), v); err != nil {`
`77`		`- return errors.Wrap(err, "failed to delete goose version")`
	`76`	`+ return fmt.Errorf("failed to delete goose version: %w", err)`
`78`	`77`	`}`
`79`	`78`	`}`
`80`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,8 @@ package goose`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"database/sql"`
	`5`	`+ "fmt"`
`5`	`6`	`"sort"`
`6`		`-`
`7`		`- "github.com/pkg/errors"`
`8`	`7`	`)`
`9`	`8`
`10`	`9`	`// Reset rolls back all migrations`
`@@ -15,15 +14,15 @@ func Reset(db *sql.DB, dir string, opts ...OptionsFunc) error {`
`15`	`14`	`}`
`16`	`15`	`migrations, err := CollectMigrations(dir, minVersion, maxVersion)`
`17`	`16`	`if err != nil {`
`18`		`- return errors.Wrap(err, "failed to collect migrations")`
	`17`	`+ return fmt.Errorf("failed to collect migrations: %w", err)`
`19`	`18`	`}`
`20`	`19`	`if option.noVersioning {`
`21`	`20`	`return DownTo(db, dir, minVersion, opts...)`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`statuses, err := dbMigrationsStatus(db)`
`25`	`24`	`if err != nil {`
`26`		`- return errors.Wrap(err, "failed to get status of migrations")`
	`25`	`+ return fmt.Errorf("failed to get status of migrations: %w", err)`
`27`	`26`	`}`
`28`	`27`	`sort.Sort(sort.Reverse(migrations))`
`29`	`28`
`@@ -32,7 +31,7 @@ func Reset(db *sql.DB, dir string, opts ...OptionsFunc) error {`
`32`	`31`	`continue`
`33`	`32`	`}`
`34`	`33`	`if err = migration.Down(db); err != nil {`
`35`		`- return errors.Wrap(err, "failed to db-down")`
	`34`	`+ return fmt.Errorf("failed to db-down: %w", err)`
`36`	`35`	`}`
`37`	`36`	`}`
`38`	`37`
`@@ -54,7 +53,7 @@ func dbMigrationsStatus(db *sql.DB) (map[int64]bool, error) {`
`54`	`53`	`for rows.Next() {`
`55`	`54`	`var row MigrationRecord`
`56`	`55`	`if err = rows.Scan(&row.VersionID, &row.IsApplied); err != nil {`
`57`		`- return nil, errors.Wrap(err, "failed to scan row")`
	`56`	`+ return nil, fmt.Errorf("failed to scan row: %w", err)`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`if _, ok := result[row.VersionID]; ok {`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,13 @@ package goose`
`3`	`3`	`import (`
`4`	`4`	`"bufio"`
`5`	`5`	`"bytes"`
	`6`	`+ "fmt"`
`6`	`7`	`"io"`
`7`	`8`	`"regexp"`
`8`	`9`	`"strings"`
`9`	`10`	`"sync"`
`10`	`11`
`11`		`- "github.com/pkg/errors"`
	`12`	`+ "errors"`
`12`	`13`	`)`
`13`	`14`
`14`	`15`	`type parserState int`
`@@ -79,7 +80,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`79`	`80`	`case start:`
`80`	`81`	`stateMachine.Set(gooseUp)`
`81`	`82`	`default:`
`82`		`- return nil, false, errors.Errorf("duplicate '-- +goose Up' annotations; stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
	`83`	`+ return nil, false, fmt.Errorf("duplicate '-- +goose Up' annotations; stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
`83`	`84`	`}`
`84`	`85`	`continue`
`85`	`86`
`@@ -88,7 +89,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`88`	`89`	`case gooseUp, gooseStatementEndUp:`
`89`	`90`	`stateMachine.Set(gooseDown)`
`90`	`91`	`default:`
`91`		`- return nil, false, errors.Errorf("must start with '-- +goose Up' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
	`92`	`+ return nil, false, fmt.Errorf("must start with '-- +goose Up' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
`92`	`93`	`}`
`93`	`94`	`continue`
`94`	`95`
`@@ -99,7 +100,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`99`	`100`	`case gooseDown, gooseStatementEndDown:`
`100`	`101`	`stateMachine.Set(gooseStatementBeginDown)`
`101`	`102`	`default:`
`102`		`- return nil, false, errors.Errorf("'-- +goose StatementBegin' must be defined after '-- +goose Up' or '-- +goose Down' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
	`103`	`+ return nil, false, fmt.Errorf("'-- +goose StatementBegin' must be defined after '-- +goose Up' or '-- +goose Down' annotation, stateMachine=%v, see https://github.com/pressly/goose#sql-migrations", stateMachine)`
`103`	`104`	`}`
`104`	`105`	`continue`
`105`	`106`
`@@ -132,7 +133,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`132`	`133`
`133`	`134`	`// Write SQL line to a buffer.`
`134`	`135`	`if _, err := buf.WriteString(line + "\n"); err != nil {`
`135`		`- return nil, false, errors.Wrap(err, "failed to write to buf")`
	`136`	`+ return nil, false, fmt.Errorf("failed to write to buf: %w", err)`
`136`	`137`	`}`
`137`	`138`
`138`	`139`	`// Read SQL body one by line, if we're in the right direction.`
`@@ -154,7 +155,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`154`	`155`	`continue`
`155`	`156`	`}`
`156`	`157`	`default:`
`157`		`- return nil, false, errors.Errorf("failed to parse migration: unexpected state %q on line %q, see https://github.com/pressly/goose#sql-migrations", stateMachine, line)`
	`158`	`+ return nil, false, fmt.Errorf("failed to parse migration: unexpected state %q on line %q, see https://github.com/pressly/goose#sql-migrations", stateMachine, line)`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`switch stateMachine.Get() {`
`@@ -183,7 +184,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`183`	`184`	`}`
`184`	`185`	`}`
`185`	`186`	`if err := scanner.Err(); err != nil {`
`186`		`- return nil, false, errors.Wrap(err, "failed to scan migration")`
	`187`	`+ return nil, false, fmt.Errorf("failed to scan migration: %w", err)`
`187`	`188`	`}`
`188`	`189`	`// EOF`
`189`	`190`
`@@ -195,7 +196,7 @@ func parseSQLMigration(r io.Reader, direction bool) (stmts []string, useTx bool,`
`195`	`196`	`}`
`196`	`197`
`197`	`198`	`if bufferRemaining := strings.TrimSpace(buf.String()); len(bufferRemaining) > 0 {`
`198`		`- return nil, false, errors.Errorf("failed to parse migration: state %q, direction: %v: unexpected unfinished SQL query: %q: missing semicolon?", stateMachine, direction, bufferRemaining)`
	`199`	`+ return nil, false, fmt.Errorf("failed to parse migration: state %q, direction: %v: unexpected unfinished SQL query: %q: missing semicolon?", stateMachine, direction, bufferRemaining)`
`199`	`200`	`}`
`200`	`201`
`201`	`202`	`return stmts, useTx, nil`