Initial commit

vendor/github.com/golang-migrate/migrate/v4/database/driver.go

@@ -0,0 +1,124 @@
+// Package database provides the Database interface.
+// All database drivers must implement this interface, register themselves,
+// optionally provide a `WithInstance` function and pass the tests
+// in package database/testing.
+package database
+
+import (
+	"fmt"
+	"io"
+	nurl "net/url"
+	"sync"
+)
+
+var (
+	ErrLocked = fmt.Errorf("can't acquire lock")
+)
+
+const NilVersion int = -1
+
+var driversMu sync.RWMutex
+var drivers = make(map[string]Driver)
+
+// Driver is the interface every database driver must implement.
+//
+// How to implement a database driver?
+//   1. Implement this interface.
+//   2. Optionally, add a function named `WithInstance`.
+//      This function should accept an existing DB instance and a Config{} struct
+//      and return a driver instance.
+//   3. Add a test that calls database/testing.go:Test()
+//   4. Add own tests for Open(), WithInstance() (when provided) and Close().
+//      All other functions are tested by tests in database/testing.
+//      Saves you some time and makes sure all database drivers behave the same way.
+//   5. Call Register in init().
+//   6. Create a migrate/cli/build_<driver-name>.go file
+//   7. Add driver name in 'DATABASE' variable in Makefile
+//
+// Guidelines:
+//   * Don't try to correct user input. Don't assume things.
+//     When in doubt, return an error and explain the situation to the user.
+//   * All configuration input must come from the URL string in func Open()
+//     or the Config{} struct in WithInstance. Don't os.Getenv().
+type Driver interface {
+	// Open returns a new driver instance configured with parameters
+	// coming from the URL string. Migrate will call this function
+	// only once per instance.
+	Open(url string) (Driver, error)
+
+	// Close closes the underlying database instance managed by the driver.
+	// Migrate will call this function only once per instance.
+	Close() error
+
+	// Lock should acquire a database lock so that only one migration process
+	// can run at a time. Migrate will call this function before Run is called.
+	// If the implementation can't provide this functionality, return nil.
+	// Return database.ErrLocked if database is already locked.
+	Lock() error
+
+	// Unlock should release the lock. Migrate will call this function after
+	// all migrations have been run.
+	Unlock() error
+
+	// Run applies a migration to the database. migration is garantueed to be not nil.
+	Run(migration io.Reader) error
+
+	// SetVersion saves version and dirty state.
+	// Migrate will call this function before and after each call to Run.
+	// version must be >= -1. -1 means NilVersion.
+	SetVersion(version int, dirty bool) error
+
+	// Version returns the currently active version and if the database is dirty.
+	// When no migration has been applied, it must return version -1.
+	// Dirty means, a previous migration failed and user interaction is required.
+	Version() (version int, dirty bool, err error)
+
+	// Drop deletes everything in the database.
+	Drop() error
+}
+
+// Open returns a new driver instance.
+func Open(url string) (Driver, error) {
+	u, err := nurl.Parse(url)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to parse URL. Did you escape all reserved URL characters? "+
+			"See: https://github.com/golang-migrate/migrate#database-urls Error: %v", err)
+	}
+
+	if u.Scheme == "" {
+		return nil, fmt.Errorf("database driver: invalid URL scheme")
+	}
+
+	driversMu.RLock()
+	d, ok := drivers[u.Scheme]
+	driversMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", u.Scheme)
+	}
+
+	return d.Open(url)
+}
+
+// Register globally registers a driver.
+func Register(name string, driver Driver) {
+	driversMu.Lock()
+	defer driversMu.Unlock()
+	if driver == nil {
+		panic("Register driver is nil")
+	}
+	if _, dup := drivers[name]; dup {
+		panic("Register called twice for driver " + name)
+	}
+	drivers[name] = driver
+}
+
+// List lists the registered drivers
+func List() []string {
+	driversMu.RLock()
+	defer driversMu.RUnlock()
+	names := make([]string, 0, len(drivers))
+	for n := range drivers {
+		names = append(names, n)
+	}
+	return names
+}

vendor/github.com/golang-migrate/migrate/v4/database/error.go

@@ -0,0 +1,27 @@
+package database
+
+import (
+	"fmt"
+)
+
+// Error should be used for errors involving queries ran against the database
+type Error struct {
+	// Optional: the line number
+	Line uint
+
+	// Query is a query excerpt
+	Query []byte
+
+	// Err is a useful/helping error message for humans
+	Err string
+
+	// OrigErr is the underlying error
+	OrigErr error
+}
+
+func (e Error) Error() string {
+	if len(e.Err) == 0 {
+		return fmt.Sprintf("%v in line %v: %s", e.OrigErr, e.Line, e.Query)
+	}
+	return fmt.Sprintf("%v in line %v: %s (details: %v)", e.Err, e.Line, e.Query, e.OrigErr)
+}

vendor/github.com/golang-migrate/migrate/v4/database/sqlite3/sqlite3.go

@@ -0,0 +1,214 @@
+package sqlite3
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	_ "github.com/mattn/go-sqlite3"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"strings"
+)
+
+func init() {
+	database.Register("sqlite3", &Sqlite{})
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+var (
+	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+)
+
+type Config struct {
+	MigrationsTable string
+	DatabaseName    string
+}
+
+type Sqlite struct {
+	db       *sql.DB
+	isLocked bool
+
+	config *Config
+}
+
+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	mx := &Sqlite{
+		db:     instance,
+		config: config,
+	}
+	if err := mx.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+	return mx, nil
+}
+
+func (m *Sqlite) ensureVersionTable() error {
+
+	query := fmt.Sprintf(`
+	CREATE TABLE IF NOT EXISTS %s (version uint64,dirty bool);
+  CREATE UNIQUE INDEX IF NOT EXISTS version_unique ON %s (version);
+  `, DefaultMigrationsTable, DefaultMigrationsTable)
+
+	if _, err := m.db.Exec(query); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *Sqlite) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+	dbfile := strings.Replace(migrate.FilterCustomQuery(purl).String(), "sqlite3://", "", 1)
+	db, err := sql.Open("sqlite3", dbfile)
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+	mx, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return mx, nil
+}
+
+func (m *Sqlite) Close() error {
+	return m.db.Close()
+}
+
+func (m *Sqlite) Drop() error {
+	query := `SELECT name FROM sqlite_master WHERE type = 'table';`
+	tables, err := m.db.Query(query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+	tableNames := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+		if len(tableName) > 0 {
+			tableNames = append(tableNames, tableName)
+		}
+	}
+	if len(tableNames) > 0 {
+		for _, t := range tableNames {
+			query := "DROP TABLE " + t
+			err = m.executeQuery(query)
+			if err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+		if err := m.ensureVersionTable(); err != nil {
+			return err
+		}
+		query := "VACUUM"
+		_, err = m.db.Query(query)
+		if err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	return nil
+}
+
+func (m *Sqlite) Lock() error {
+	if m.isLocked {
+		return database.ErrLocked
+	}
+	m.isLocked = true
+	return nil
+}
+
+func (m *Sqlite) Unlock() error {
+	if !m.isLocked {
+		return nil
+	}
+	m.isLocked = false
+	return nil
+}
+
+func (m *Sqlite) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	query := string(migr[:])
+
+	return m.executeQuery(query)
+}
+
+func (m *Sqlite) executeQuery(query string) error {
+	tx, err := m.db.Begin()
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+	if _, err := tx.Exec(query); err != nil {
+		tx.Rollback()
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if err := tx.Commit(); err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction commit failed"}
+	}
+	return nil
+}
+
+func (m *Sqlite) SetVersion(version int, dirty bool) error {
+	tx, err := m.db.Begin()
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+
+	query := "DELETE FROM " + m.config.MigrationsTable
+	if _, err := tx.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if version >= 0 {
+		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (%d, '%t')`, m.config.MigrationsTable, version, dirty)
+		if _, err := tx.Exec(query); err != nil {
+			tx.Rollback()
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction commit failed"}
+	}
+
+	return nil
+}
+
+func (m *Sqlite) Version() (version int, dirty bool, err error) {
+	query := "SELECT version, dirty FROM " + m.config.MigrationsTable + " LIMIT 1"
+	err = m.db.QueryRow(query).Scan(&version, &dirty)
+	if err != nil {
+		return database.NilVersion, false, nil
+	}
+	return version, dirty, nil
+}

vendor/github.com/golang-migrate/migrate/v4/database/util.go

@@ -0,0 +1,19 @@
+package database
+
+import (
+	"fmt"
+	"hash/crc32"
+	"strings"
+)
+
+const advisoryLockIdSalt uint = 1486364155
+
+// GenerateAdvisoryLockId inspired by rails migrations, see https://goo.gl/8o9bCT
+func GenerateAdvisoryLockId(databaseName string, additionalNames ...string) (string, error) {
+	if len(additionalNames) > 0 {
+		databaseName = strings.Join(append(additionalNames, databaseName), "\x00")
+	}
+	sum := crc32.ChecksumIEEE([]byte(databaseName))
+	sum = sum * uint32(advisoryLockIdSalt)
+	return fmt.Sprintf("%v", sum), nil
+}