Refactor drivers into separate packages (#179)

`dbmate` package was starting to get a bit polluted. This PR migrates each driver into a separate package, with clean separation between each.

In addition:

* Drivers are now initialized with a URL, avoiding the need to pass `*url.URL` to every method
* Sqlite supports a cleaner syntax for relative paths
* Driver tests now load their test URL from environment variables

Public API of `dbmate` package has not changed (no changes to `main` package).

pkg/driver/clickhouse/clickhouse.go

@@ -0,0 +1,326 @@
+package clickhouse
+
+import (
+	"bytes"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/ClickHouse/clickhouse-go"
+)
+
+func init() {
+	dbmate.RegisterDriver(NewDriver, "clickhouse")
+}
+
+// Driver provides top level database functions
+type Driver struct {
+	migrationsTableName string
+	databaseURL         *url.URL
+}
+
+// NewDriver initializes the driver
+func NewDriver(config dbmate.DriverConfig) dbmate.Driver {
+	return &Driver{
+		migrationsTableName: config.MigrationsTableName,
+		databaseURL:         config.DatabaseURL,
+	}
+}
+
+func connectionString(initialURL *url.URL) string {
+	u := *initialURL
+
+	u.Scheme = "tcp"
+	host := u.Host
+	if u.Port() == "" {
+		host = fmt.Sprintf("%s:9000", host)
+	}
+	u.Host = host
+
+	query := u.Query()
+	if query.Get("username") == "" && u.User.Username() != "" {
+		query.Set("username", u.User.Username())
+	}
+	password, passwordSet := u.User.Password()
+	if query.Get("password") == "" && passwordSet {
+		query.Set("password", password)
+	}
+	u.User = nil
+
+	if query.Get("database") == "" {
+		path := strings.Trim(u.Path, "/")
+		if path != "" {
+			query.Set("database", path)
+			u.Path = ""
+		}
+	}
+	u.RawQuery = query.Encode()
+
+	return u.String()
+}
+
+// Open creates a new database connection
+func (drv *Driver) Open() (*sql.DB, error) {
+	return sql.Open("clickhouse", connectionString(drv.databaseURL))
+}
+
+func (drv *Driver) openClickHouseDB() (*sql.DB, error) {
+	// clone databaseURL
+	clickhouseURL, err := url.Parse(connectionString(drv.databaseURL))
+	if err != nil {
+		return nil, err
+	}
+
+	// connect to clickhouse database
+	values := clickhouseURL.Query()
+	values.Set("database", "default")
+	clickhouseURL.RawQuery = values.Encode()
+
+	return sql.Open("clickhouse", clickhouseURL.String())
+}
+
+func (drv *Driver) databaseName() string {
+	name := dbutil.MustParseURL(connectionString(drv.databaseURL)).Query().Get("database")
+	if name == "" {
+		name = "default"
+	}
+	return name
+}
+
+var clickhouseValidIdentifier = regexp.MustCompile(`^[a-zA-Z_][0-9a-zA-Z_]*$`)
+
+func (drv *Driver) quoteIdentifier(str string) string {
+	if clickhouseValidIdentifier.MatchString(str) {
+		return str
+	}
+
+	str = strings.Replace(str, `"`, `""`, -1)
+
+	return fmt.Sprintf(`"%s"`, str)
+}
+
+// CreateDatabase creates the specified database
+func (drv *Driver) CreateDatabase() error {
+	name := drv.databaseName()
+	fmt.Printf("Creating: %s\n", name)
+
+	db, err := drv.openClickHouseDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec("create database " + drv.quoteIdentifier(name))
+
+	return err
+}
+
+// DropDatabase drops the specified database (if it exists)
+func (drv *Driver) DropDatabase() error {
+	name := drv.databaseName()
+	fmt.Printf("Dropping: %s\n", name)
+
+	db, err := drv.openClickHouseDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec("drop database if exists " + drv.quoteIdentifier(name))
+
+	return err
+}
+
+func (drv *Driver) schemaDump(db *sql.DB, buf *bytes.Buffer, databaseName string) error {
+	buf.WriteString("\n--\n-- Database schema\n--\n\n")
+
+	buf.WriteString("CREATE DATABASE " + drv.quoteIdentifier(databaseName) + " IF NOT EXISTS;\n\n")
+
+	tables, err := dbutil.QueryColumn(db, "show tables")
+	if err != nil {
+		return err
+	}
+	sort.Strings(tables)
+
+	for _, table := range tables {
+		var clause string
+		err = db.QueryRow("show create table " + drv.quoteIdentifier(table)).Scan(&clause)
+		if err != nil {
+			return err
+		}
+		buf.WriteString(clause + ";\n\n")
+	}
+	return nil
+}
+
+func (drv *Driver) schemaMigrationsDump(db *sql.DB, buf *bytes.Buffer) error {
+	migrationsTable := drv.quotedMigrationsTableName()
+
+	// load applied migrations
+	migrations, err := dbutil.QueryColumn(db,
+		fmt.Sprintf("select version from %s final ", migrationsTable)+
+			"where applied order by version asc",
+	)
+	if err != nil {
+		return err
+	}
+
+	quoter := strings.NewReplacer(`\`, `\\`, `'`, `\'`)
+	for i := range migrations {
+		migrations[i] = "'" + quoter.Replace(migrations[i]) + "'"
+	}
+
+	// build schema migrations table data
+	buf.WriteString("\n--\n-- Dbmate schema migrations\n--\n\n")
+
+	if len(migrations) > 0 {
+		buf.WriteString(
+			fmt.Sprintf("INSERT INTO %s (version) VALUES\n    (", migrationsTable) +
+				strings.Join(migrations, "),\n    (") +
+				");\n")
+	}
+
+	return nil
+}
+
+// DumpSchema returns the current database schema
+func (drv *Driver) DumpSchema(db *sql.DB) ([]byte, error) {
+	var buf bytes.Buffer
+	var err error
+
+	err = drv.schemaDump(db, &buf, drv.databaseName())
+	if err != nil {
+		return nil, err
+	}
+
+	err = drv.schemaMigrationsDump(db, &buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// DatabaseExists determines whether the database exists
+func (drv *Driver) DatabaseExists() (bool, error) {
+	name := drv.databaseName()
+
+	db, err := drv.openClickHouseDB()
+	if err != nil {
+		return false, err
+	}
+	defer dbutil.MustClose(db)
+
+	exists := false
+	err = db.QueryRow("SELECT 1 FROM system.databases where name = ?", name).
+		Scan(&exists)
+	if err == sql.ErrNoRows {
+		return false, nil
+	}
+
+	return exists, err
+}
+
+// CreateMigrationsTable creates the schema migrations table
+func (drv *Driver) CreateMigrationsTable(db *sql.DB) error {
+	_, err := db.Exec(fmt.Sprintf(`
+		create table if not exists %s (
+			version String,
+			ts DateTime default now(),
+			applied UInt8 default 1
+		) engine = ReplacingMergeTree(ts)
+		primary key version
+		order by version
+	`, drv.quotedMigrationsTableName()))
+
+	return err
+}
+
+// SelectMigrations returns a list of applied migrations
+// with an optional limit (in descending order)
+func (drv *Driver) SelectMigrations(db *sql.DB, limit int) (map[string]bool, error) {
+	query := fmt.Sprintf("select version from %s final where applied order by version desc",
+		drv.quotedMigrationsTableName())
+
+	if limit >= 0 {
+		query = fmt.Sprintf("%s limit %d", query, limit)
+	}
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer dbutil.MustClose(rows)
+
+	migrations := map[string]bool{}
+	for rows.Next() {
+		var version string
+		if err := rows.Scan(&version); err != nil {
+			return nil, err
+		}
+
+		migrations[version] = true
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return migrations, nil
+}
+
+// InsertMigration adds a new migration record
+func (drv *Driver) InsertMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("insert into %s (version) values (?)", drv.quotedMigrationsTableName()),
+		version)
+
+	return err
+}
+
+// DeleteMigration removes a migration record
+func (drv *Driver) DeleteMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("insert into %s (version, applied) values (?, ?)",
+			drv.quotedMigrationsTableName()),
+		version, false,
+	)
+
+	return err
+}
+
+// Ping verifies a connection to the database server. It does not verify whether the
+// specified database exists.
+func (drv *Driver) Ping() error {
+	// attempt connection to primary database, not "clickhouse" database
+	// to support servers with no "clickhouse" database
+	// (see https://github.com/amacneil/dbmate/issues/78)
+	db, err := drv.Open()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	err = db.Ping()
+	if err == nil {
+		return nil
+	}
+
+	// ignore 'Database foo doesn't exist' error
+	chErr, ok := err.(*clickhouse.Exception)
+	if ok && chErr.Code == 81 {
+		return nil
+	}
+
+	return err
+}
+
+func (drv *Driver) quotedMigrationsTableName() string {
+	return drv.quoteIdentifier(drv.migrationsTableName)
+}

pkg/driver/clickhouse/clickhouse_test.go

@@ -0,0 +1,376 @@
+package clickhouse
+
+import (
+	"database/sql"
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/stretchr/testify/require"
+)
+
+func testClickHouseDriver(t *testing.T) *Driver {
+	u := dbutil.MustParseURL(os.Getenv("CLICKHOUSE_TEST_URL"))
+	drv, err := dbmate.New(u).GetDriver()
+	require.NoError(t, err)
+
+	return drv.(*Driver)
+}
+
+func prepTestClickHouseDB(t *testing.T) *sql.DB {
+	drv := testClickHouseDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// connect database
+	db, err := sql.Open("clickhouse", drv.databaseURL.String())
+	require.NoError(t, err)
+
+	return db
+}
+
+func TestGetDriver(t *testing.T) {
+	db := dbmate.New(dbutil.MustParseURL("clickhouse://"))
+	drvInterface, err := db.GetDriver()
+	require.NoError(t, err)
+
+	// driver should have URL and default migrations table set
+	drv, ok := drvInterface.(*Driver)
+	require.True(t, ok)
+	require.Equal(t, db.DatabaseURL.String(), drv.databaseURL.String())
+	require.Equal(t, "schema_migrations", drv.migrationsTableName)
+}
+
+func TestConnectionString(t *testing.T) {
+	t.Run("simple", func(t *testing.T) {
+		u, err := url.Parse("clickhouse://user:pass@host/db")
+		require.NoError(t, err)
+
+		s := connectionString(u)
+		require.Equal(t, "tcp://host:9000?database=db&password=pass&username=user", s)
+	})
+
+	t.Run("canonical", func(t *testing.T) {
+		u, err := url.Parse("clickhouse://host:9000?database=db&password=pass&username=user")
+		require.NoError(t, err)
+
+		s := connectionString(u)
+		require.Equal(t, "tcp://host:9000?database=db&password=pass&username=user", s)
+	})
+}
+
+func TestClickHouseCreateDropDatabase(t *testing.T) {
+	drv := testClickHouseDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// check that database exists and we can connect to it
+	func() {
+		db, err := sql.Open("clickhouse", drv.databaseURL.String())
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.NoError(t, err)
+	}()
+
+	// drop the database
+	err = drv.DropDatabase()
+	require.NoError(t, err)
+
+	// check that database no longer exists
+	func() {
+		db, err := sql.Open("clickhouse", drv.databaseURL.String())
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.EqualError(t, err, "code: 81, message: Database dbmate_test doesn't exist")
+	}()
+}
+
+func TestClickHouseDumpSchema(t *testing.T) {
+	drv := testClickHouseDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	// prepare database
+	db := prepTestClickHouseDB(t)
+	defer dbutil.MustClose(db)
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	// insert migration
+	tx, err := db.Begin()
+	require.NoError(t, err)
+	err = drv.InsertMigration(tx, "abc1")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+	tx, err = db.Begin()
+	require.NoError(t, err)
+	err = drv.InsertMigration(tx, "abc2")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+
+	// DumpSchema should return schema
+	schema, err := drv.DumpSchema(db)
+	require.NoError(t, err)
+	require.Contains(t, string(schema), "CREATE TABLE "+drv.databaseName()+".test_migrations")
+	require.Contains(t, string(schema), "--\n"+
+		"-- Dbmate schema migrations\n"+
+		"--\n\n"+
+		"INSERT INTO test_migrations (version) VALUES\n"+
+		"    ('abc1'),\n"+
+		"    ('abc2');\n")
+
+	// DumpSchema should return error if command fails
+	values := drv.databaseURL.Query()
+	values.Set("database", "fakedb")
+	drv.databaseURL.RawQuery = values.Encode()
+	db, err = sql.Open("clickhouse", drv.databaseURL.String())
+	require.NoError(t, err)
+
+	schema, err = drv.DumpSchema(db)
+	require.Nil(t, schema)
+	require.EqualError(t, err, "code: 81, message: Database fakedb doesn't exist")
+}
+
+func TestClickHouseDatabaseExists(t *testing.T) {
+	drv := testClickHouseDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return false
+	exists, err := drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, false, exists)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return true
+	exists, err = drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, true, exists)
+}
+
+func TestClickHouseDatabaseExists_Error(t *testing.T) {
+	drv := testClickHouseDriver(t)
+	values := drv.databaseURL.Query()
+	values.Set("username", "invalid")
+	drv.databaseURL.RawQuery = values.Encode()
+
+	exists, err := drv.DatabaseExists()
+	require.EqualError(t, err, "code: 192, message: Unknown user invalid")
+	require.Equal(t, false, exists)
+}
+
+func TestClickHouseCreateMigrationsTable(t *testing.T) {
+	t.Run("default table", func(t *testing.T) {
+		drv := testClickHouseDriver(t)
+		db := prepTestClickHouseDB(t)
+		defer dbutil.MustClose(db)
+
+		// migrations table should not exist
+		count := 0
+		err := db.QueryRow("select count(*) from schema_migrations").Scan(&count)
+		require.EqualError(t, err, "code: 60, message: Table dbmate_test.schema_migrations doesn't exist.")
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// migrations table should exist
+		err = db.QueryRow("select count(*) from schema_migrations").Scan(&count)
+		require.NoError(t, err)
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+
+	t.Run("custom table", func(t *testing.T) {
+		drv := testClickHouseDriver(t)
+		drv.migrationsTableName = "testMigrations"
+
+		db := prepTestClickHouseDB(t)
+		defer dbutil.MustClose(db)
+
+		// migrations table should not exist
+		count := 0
+		err := db.QueryRow("select count(*) from \"testMigrations\"").Scan(&count)
+		require.EqualError(t, err, "code: 60, message: Table dbmate_test.testMigrations doesn't exist.")
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// migrations table should exist
+		err = db.QueryRow("select count(*) from \"testMigrations\"").Scan(&count)
+		require.NoError(t, err)
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+}
+
+func TestClickHouseSelectMigrations(t *testing.T) {
+	drv := testClickHouseDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestClickHouseDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	tx, err := db.Begin()
+	require.NoError(t, err)
+	stmt, err := tx.Prepare("insert into test_migrations (version) values (?)")
+	require.NoError(t, err)
+	_, err = stmt.Exec("abc2")
+	require.NoError(t, err)
+	_, err = stmt.Exec("abc1")
+	require.NoError(t, err)
+	_, err = stmt.Exec("abc3")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+
+	migrations, err := drv.SelectMigrations(db, -1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc1"])
+	require.Equal(t, true, migrations["abc2"])
+	require.Equal(t, true, migrations["abc2"])
+
+	// test limit param
+	migrations, err = drv.SelectMigrations(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc3"])
+	require.Equal(t, false, migrations["abc1"])
+	require.Equal(t, false, migrations["abc2"])
+}
+
+func TestClickHouseInsertMigration(t *testing.T) {
+	drv := testClickHouseDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestClickHouseDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 0, count)
+
+	// insert migration
+	tx, err := db.Begin()
+	require.NoError(t, err)
+	err = drv.InsertMigration(tx, "abc1")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+
+	err = db.QueryRow("select count(*) from test_migrations where version = 'abc1'").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestClickHouseDeleteMigration(t *testing.T) {
+	drv := testClickHouseDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestClickHouseDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	tx, err := db.Begin()
+	require.NoError(t, err)
+	stmt, err := tx.Prepare("insert into test_migrations (version) values (?)")
+	require.NoError(t, err)
+	_, err = stmt.Exec("abc2")
+	require.NoError(t, err)
+	_, err = stmt.Exec("abc1")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+
+	tx, err = db.Begin()
+	require.NoError(t, err)
+	err = drv.DeleteMigration(tx, "abc2")
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations final where applied").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestClickHousePing(t *testing.T) {
+	drv := testClickHouseDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// ping database
+	err = drv.Ping()
+	require.NoError(t, err)
+
+	// ping invalid host should return error
+	drv.databaseURL.Host = "clickhouse:404"
+	err = drv.Ping()
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "connect: connection refused")
+}
+
+func TestClickHouseQuotedMigrationsTableName(t *testing.T) {
+	t.Run("default name", func(t *testing.T) {
+		drv := testClickHouseDriver(t)
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, "schema_migrations", name)
+	})
+
+	t.Run("custom name", func(t *testing.T) {
+		drv := testClickHouseDriver(t)
+		drv.migrationsTableName = "fooMigrations"
+
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, "fooMigrations", name)
+	})
+
+	t.Run("quoted name", func(t *testing.T) {
+		drv := testClickHouseDriver(t)
+		drv.migrationsTableName = "bizarre\"$name"
+
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, `"bizarre""$name"`, name)
+	})
+}

pkg/driver/mysql/mysql.go

@@ -0,0 +1,287 @@
+package mysql
+
+import (
+	"bytes"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	_ "github.com/go-sql-driver/mysql" // database/sql driver
+)
+
+func init() {
+	dbmate.RegisterDriver(NewDriver, "mysql")
+}
+
+// Driver provides top level database functions
+type Driver struct {
+	migrationsTableName string
+	databaseURL         *url.URL
+}
+
+// NewDriver initializes the driver
+func NewDriver(config dbmate.DriverConfig) dbmate.Driver {
+	return &Driver{
+		migrationsTableName: config.MigrationsTableName,
+		databaseURL:         config.DatabaseURL,
+	}
+}
+
+func connectionString(u *url.URL) string {
+	query := u.Query()
+	query.Set("multiStatements", "true")
+
+	host := u.Host
+	protocol := "tcp"
+
+	if query.Get("socket") != "" {
+		protocol = "unix"
+		host = query.Get("socket")
+		query.Del("socket")
+	} else if u.Port() == "" {
+		// set default port
+		host = fmt.Sprintf("%s:3306", host)
+	}
+
+	// Get decoded user:pass
+	userPassEncoded := u.User.String()
+	userPass, _ := url.QueryUnescape(userPassEncoded)
+
+	// Build DSN w/ user:pass percent-decoded
+	normalizedString := ""
+
+	if userPass != "" { // user:pass can be empty
+		normalizedString = userPass + "@"
+	}
+
+	// connection string format required by go-sql-driver/mysql
+	normalizedString = fmt.Sprintf("%s%s(%s)%s?%s", normalizedString,
+		protocol, host, u.Path, query.Encode())
+
+	return normalizedString
+}
+
+// Open creates a new database connection
+func (drv *Driver) Open() (*sql.DB, error) {
+	return sql.Open("mysql", connectionString(drv.databaseURL))
+}
+
+func (drv *Driver) openRootDB() (*sql.DB, error) {
+	// clone databaseURL
+	rootURL, err := url.Parse(drv.databaseURL.String())
+	if err != nil {
+		return nil, err
+	}
+
+	// connect to no particular database
+	rootURL.Path = "/"
+
+	return sql.Open("mysql", connectionString(rootURL))
+}
+
+func (drv *Driver) quoteIdentifier(str string) string {
+	str = strings.Replace(str, "`", "\\`", -1)
+
+	return fmt.Sprintf("`%s`", str)
+}
+
+// CreateDatabase creates the specified database
+func (drv *Driver) CreateDatabase() error {
+	name := dbutil.DatabaseName(drv.databaseURL)
+	fmt.Printf("Creating: %s\n", name)
+
+	db, err := drv.openRootDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec(fmt.Sprintf("create database %s",
+		drv.quoteIdentifier(name)))
+
+	return err
+}
+
+// DropDatabase drops the specified database (if it exists)
+func (drv *Driver) DropDatabase() error {
+	name := dbutil.DatabaseName(drv.databaseURL)
+	fmt.Printf("Dropping: %s\n", name)
+
+	db, err := drv.openRootDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec(fmt.Sprintf("drop database if exists %s",
+		drv.quoteIdentifier(name)))
+
+	return err
+}
+
+func (drv *Driver) mysqldumpArgs() []string {
+	// generate CLI arguments
+	args := []string{"--opt", "--routines", "--no-data",
+		"--skip-dump-date", "--skip-add-drop-table"}
+
+	if hostname := drv.databaseURL.Hostname(); hostname != "" {
+		args = append(args, "--host="+hostname)
+	}
+	if port := drv.databaseURL.Port(); port != "" {
+		args = append(args, "--port="+port)
+	}
+	if username := drv.databaseURL.User.Username(); username != "" {
+		args = append(args, "--user="+username)
+	}
+	// mysql recommends against using environment variables to supply password
+	// https://dev.mysql.com/doc/refman/5.7/en/password-security-user.html
+	if password, set := drv.databaseURL.User.Password(); set {
+		args = append(args, "--password="+password)
+	}
+
+	// add database name
+	args = append(args, dbutil.DatabaseName(drv.databaseURL))
+
+	return args
+}
+
+func (drv *Driver) schemaMigrationsDump(db *sql.DB) ([]byte, error) {
+	migrationsTable := drv.quotedMigrationsTableName()
+
+	// load applied migrations
+	migrations, err := dbutil.QueryColumn(db,
+		fmt.Sprintf("select quote(version) from %s order by version asc", migrationsTable))
+	if err != nil {
+		return nil, err
+	}
+
+	// build schema_migrations table data
+	var buf bytes.Buffer
+	buf.WriteString("\n--\n-- Dbmate schema migrations\n--\n\n" +
+		fmt.Sprintf("LOCK TABLES %s WRITE;\n", migrationsTable))
+
+	if len(migrations) > 0 {
+		buf.WriteString(
+			fmt.Sprintf("INSERT INTO %s (version) VALUES\n  (", migrationsTable) +
+				strings.Join(migrations, "),\n  (") +
+				");\n")
+	}
+
+	buf.WriteString("UNLOCK TABLES;\n")
+
+	return buf.Bytes(), nil
+}
+
+// DumpSchema returns the current database schema
+func (drv *Driver) DumpSchema(db *sql.DB) ([]byte, error) {
+	schema, err := dbutil.RunCommand("mysqldump", drv.mysqldumpArgs()...)
+	if err != nil {
+		return nil, err
+	}
+
+	migrations, err := drv.schemaMigrationsDump(db)
+	if err != nil {
+		return nil, err
+	}
+
+	schema = append(schema, migrations...)
+	return dbutil.TrimLeadingSQLComments(schema)
+}
+
+// DatabaseExists determines whether the database exists
+func (drv *Driver) DatabaseExists() (bool, error) {
+	name := dbutil.DatabaseName(drv.databaseURL)
+
+	db, err := drv.openRootDB()
+	if err != nil {
+		return false, err
+	}
+	defer dbutil.MustClose(db)
+
+	exists := false
+	err = db.QueryRow("select true from information_schema.schemata "+
+		"where schema_name = ?", name).Scan(&exists)
+	if err == sql.ErrNoRows {
+		return false, nil
+	}
+
+	return exists, err
+}
+
+// CreateMigrationsTable creates the schema_migrations table
+func (drv *Driver) CreateMigrationsTable(db *sql.DB) error {
+	_, err := db.Exec(fmt.Sprintf("create table if not exists %s "+
+		"(version varchar(255) primary key) character set latin1 collate latin1_bin",
+		drv.quotedMigrationsTableName()))
+
+	return err
+}
+
+// SelectMigrations returns a list of applied migrations
+// with an optional limit (in descending order)
+func (drv *Driver) SelectMigrations(db *sql.DB, limit int) (map[string]bool, error) {
+	query := fmt.Sprintf("select version from %s order by version desc", drv.quotedMigrationsTableName())
+	if limit >= 0 {
+		query = fmt.Sprintf("%s limit %d", query, limit)
+	}
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer dbutil.MustClose(rows)
+
+	migrations := map[string]bool{}
+	for rows.Next() {
+		var version string
+		if err := rows.Scan(&version); err != nil {
+			return nil, err
+		}
+
+		migrations[version] = true
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return migrations, nil
+}
+
+// InsertMigration adds a new migration record
+func (drv *Driver) InsertMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("insert into %s (version) values (?)", drv.quotedMigrationsTableName()),
+		version)
+
+	return err
+}
+
+// DeleteMigration removes a migration record
+func (drv *Driver) DeleteMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("delete from %s where version = ?", drv.quotedMigrationsTableName()),
+		version)
+
+	return err
+}
+
+// Ping verifies a connection to the database server. It does not verify whether the
+// specified database exists.
+func (drv *Driver) Ping() error {
+	db, err := drv.openRootDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	return db.Ping()
+}
+
+func (drv *Driver) quotedMigrationsTableName() string {
+	return drv.quoteIdentifier(drv.migrationsTableName)
+}

pkg/driver/mysql/mysql_test.go

@@ -0,0 +1,342 @@
+package mysql
+
+import (
+	"database/sql"
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/stretchr/testify/require"
+)
+
+func testMySQLDriver(t *testing.T) *Driver {
+	u := dbutil.MustParseURL(os.Getenv("MYSQL_TEST_URL"))
+	drv, err := dbmate.New(u).GetDriver()
+	require.NoError(t, err)
+
+	return drv.(*Driver)
+}
+
+func prepTestMySQLDB(t *testing.T) *sql.DB {
+	drv := testMySQLDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// connect database
+	db, err := drv.Open()
+	require.NoError(t, err)
+
+	return db
+}
+
+func TestGetDriver(t *testing.T) {
+	db := dbmate.New(dbutil.MustParseURL("mysql://"))
+	drvInterface, err := db.GetDriver()
+	require.NoError(t, err)
+
+	// driver should have URL and default migrations table set
+	drv, ok := drvInterface.(*Driver)
+	require.True(t, ok)
+	require.Equal(t, db.DatabaseURL.String(), drv.databaseURL.String())
+	require.Equal(t, "schema_migrations", drv.migrationsTableName)
+}
+
+func TestConnectionString(t *testing.T) {
+	t.Run("defaults", func(t *testing.T) {
+		u, err := url.Parse("mysql://host/foo")
+		require.NoError(t, err)
+		require.Equal(t, "", u.Port())
+
+		s := connectionString(u)
+		require.Equal(t, "tcp(host:3306)/foo?multiStatements=true", s)
+	})
+
+	t.Run("custom", func(t *testing.T) {
+		u, err := url.Parse("mysql://bob:secret@host:123/foo?flag=on")
+		require.NoError(t, err)
+		require.Equal(t, "123", u.Port())
+
+		s := connectionString(u)
+		require.Equal(t, "bob:secret@tcp(host:123)/foo?flag=on&multiStatements=true", s)
+	})
+
+	t.Run("special chars", func(t *testing.T) {
+		u, err := url.Parse("mysql://duhfsd7s:123!@123!@@host:123/foo?flag=on")
+		require.NoError(t, err)
+		require.Equal(t, "123", u.Port())
+
+		s := connectionString(u)
+		require.Equal(t, "duhfsd7s:123!@123!@@tcp(host:123)/foo?flag=on&multiStatements=true", s)
+	})
+
+	t.Run("socket", func(t *testing.T) {
+		// test with no user/pass
+		u, err := url.Parse("mysql:///foo?socket=/var/run/mysqld/mysqld.sock&flag=on")
+		require.NoError(t, err)
+		require.Equal(t, "", u.Host)
+
+		s := connectionString(u)
+		require.Equal(t, "unix(/var/run/mysqld/mysqld.sock)/foo?flag=on&multiStatements=true", s)
+
+		// test with user/pass
+		u, err = url.Parse("mysql://bob:secret@fakehost/foo?socket=/var/run/mysqld/mysqld.sock&flag=on")
+		require.NoError(t, err)
+
+		s = connectionString(u)
+		require.Equal(t, "bob:secret@unix(/var/run/mysqld/mysqld.sock)/foo?flag=on&multiStatements=true", s)
+	})
+}
+
+func TestMySQLCreateDropDatabase(t *testing.T) {
+	drv := testMySQLDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// check that database exists and we can connect to it
+	func() {
+		db, err := drv.Open()
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.NoError(t, err)
+	}()
+
+	// drop the database
+	err = drv.DropDatabase()
+	require.NoError(t, err)
+
+	// check that database no longer exists
+	func() {
+		db, err := drv.Open()
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.Error(t, err)
+		require.Regexp(t, "Unknown database 'dbmate_test'", err.Error())
+	}()
+}
+
+func TestMySQLDumpSchema(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	// prepare database
+	db := prepTestMySQLDB(t)
+	defer dbutil.MustClose(db)
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	// insert migration
+	err = drv.InsertMigration(db, "abc1")
+	require.NoError(t, err)
+	err = drv.InsertMigration(db, "abc2")
+	require.NoError(t, err)
+
+	// DumpSchema should return schema
+	schema, err := drv.DumpSchema(db)
+	require.NoError(t, err)
+	require.Contains(t, string(schema), "CREATE TABLE `test_migrations`")
+	require.Contains(t, string(schema), "\n-- Dump completed\n\n"+
+		"--\n"+
+		"-- Dbmate schema migrations\n"+
+		"--\n\n"+
+		"LOCK TABLES `test_migrations` WRITE;\n"+
+		"INSERT INTO `test_migrations` (version) VALUES\n"+
+		"  ('abc1'),\n"+
+		"  ('abc2');\n"+
+		"UNLOCK TABLES;\n")
+
+	// DumpSchema should return error if command fails
+	drv.databaseURL.Path = "/fakedb"
+	schema, err = drv.DumpSchema(db)
+	require.Nil(t, schema)
+	require.EqualError(t, err, "mysqldump: [Warning] Using a password "+
+		"on the command line interface can be insecure.\n"+
+		"mysqldump: Got error: 1049: "+
+		"Unknown database 'fakedb' when selecting the database")
+}
+
+func TestMySQLDatabaseExists(t *testing.T) {
+	drv := testMySQLDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return false
+	exists, err := drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, false, exists)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return true
+	exists, err = drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, true, exists)
+}
+
+func TestMySQLDatabaseExists_Error(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.databaseURL.User = url.User("invalid")
+
+	exists, err := drv.DatabaseExists()
+	require.Error(t, err)
+	require.Regexp(t, "Access denied for user 'invalid'@", err.Error())
+	require.Equal(t, false, exists)
+}
+
+func TestMySQLCreateMigrationsTable(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestMySQLDB(t)
+	defer dbutil.MustClose(db)
+
+	// migrations table should not exist
+	count := 0
+	err := db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.Error(t, err)
+	require.Regexp(t, "Table 'dbmate_test.test_migrations' doesn't exist", err.Error())
+
+	// create table
+	err = drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	// migrations table should exist
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+
+	// create table should be idempotent
+	err = drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+}
+
+func TestMySQLSelectMigrations(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestMySQLDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into test_migrations (version)
+		values ('abc2'), ('abc1'), ('abc3')`)
+	require.NoError(t, err)
+
+	migrations, err := drv.SelectMigrations(db, -1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc1"])
+	require.Equal(t, true, migrations["abc2"])
+	require.Equal(t, true, migrations["abc2"])
+
+	// test limit param
+	migrations, err = drv.SelectMigrations(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc3"])
+	require.Equal(t, false, migrations["abc1"])
+	require.Equal(t, false, migrations["abc2"])
+}
+
+func TestMySQLInsertMigration(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestMySQLDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 0, count)
+
+	// insert migration
+	err = drv.InsertMigration(db, "abc1")
+	require.NoError(t, err)
+
+	err = db.QueryRow("select count(*) from test_migrations where version = 'abc1'").
+		Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestMySQLDeleteMigration(t *testing.T) {
+	drv := testMySQLDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestMySQLDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into test_migrations (version)
+		values ('abc1'), ('abc2')`)
+	require.NoError(t, err)
+
+	err = drv.DeleteMigration(db, "abc2")
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestMySQLPing(t *testing.T) {
+	drv := testMySQLDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// ping database
+	err = drv.Ping()
+	require.NoError(t, err)
+
+	// ping invalid host should return error
+	drv.databaseURL.Host = "mysql:404"
+	err = drv.Ping()
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "connect: connection refused")
+}
+
+func TestMySQLQuotedMigrationsTableName(t *testing.T) {
+	t.Run("default name", func(t *testing.T) {
+		drv := testMySQLDriver(t)
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, "`schema_migrations`", name)
+	})
+
+	t.Run("custom name", func(t *testing.T) {
+		drv := testMySQLDriver(t)
+		drv.migrationsTableName = "fooMigrations"
+
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, "`fooMigrations`", name)
+	})
+}

pkg/driver/postgres/postgres.go

@@ -0,0 +1,382 @@
+package postgres
+
+import (
+	"bytes"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/lib/pq"
+)
+
+func init() {
+	dbmate.RegisterDriver(NewDriver, "postgres")
+	dbmate.RegisterDriver(NewDriver, "postgresql")
+}
+
+// Driver provides top level database functions
+type Driver struct {
+	migrationsTableName string
+	databaseURL         *url.URL
+}
+
+// NewDriver initializes the driver
+func NewDriver(config dbmate.DriverConfig) dbmate.Driver {
+	return &Driver{
+		migrationsTableName: config.MigrationsTableName,
+		databaseURL:         config.DatabaseURL,
+	}
+}
+
+func connectionString(u *url.URL) string {
+	hostname := u.Hostname()
+	port := u.Port()
+	query := u.Query()
+
+	// support socket parameter for consistency with mysql
+	if query.Get("socket") != "" {
+		query.Set("host", query.Get("socket"))
+		query.Del("socket")
+	}
+
+	// default hostname
+	if hostname == "" {
+		hostname = "localhost"
+	}
+
+	// host param overrides url hostname
+	if query.Get("host") != "" {
+		hostname = ""
+	}
+
+	// always specify a port
+	if query.Get("port") != "" {
+		port = query.Get("port")
+		query.Del("port")
+	}
+	if port == "" {
+		port = "5432"
+	}
+
+	// generate output URL
+	out, _ := url.Parse(u.String())
+	out.Host = fmt.Sprintf("%s:%s", hostname, port)
+	out.RawQuery = query.Encode()
+
+	return out.String()
+}
+
+func connectionArgsForDump(u *url.URL) []string {
+	u = dbutil.MustParseURL(connectionString(u))
+
+	// find schemas from search_path
+	query := u.Query()
+	schemas := strings.Split(query.Get("search_path"), ",")
+	query.Del("search_path")
+	u.RawQuery = query.Encode()
+
+	out := []string{}
+	for _, schema := range schemas {
+		schema = strings.TrimSpace(schema)
+		if schema != "" {
+			out = append(out, "--schema", schema)
+		}
+	}
+	out = append(out, u.String())
+
+	return out
+}
+
+// Open creates a new database connection
+func (drv *Driver) Open() (*sql.DB, error) {
+	return sql.Open("postgres", connectionString(drv.databaseURL))
+}
+
+func (drv *Driver) openPostgresDB() (*sql.DB, error) {
+	// clone databaseURL
+	postgresURL, err := url.Parse(connectionString(drv.databaseURL))
+	if err != nil {
+		return nil, err
+	}
+
+	// connect to postgres database
+	postgresURL.Path = "postgres"
+
+	return sql.Open("postgres", postgresURL.String())
+}
+
+// CreateDatabase creates the specified database
+func (drv *Driver) CreateDatabase() error {
+	name := dbutil.DatabaseName(drv.databaseURL)
+	fmt.Printf("Creating: %s\n", name)
+
+	db, err := drv.openPostgresDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec(fmt.Sprintf("create database %s",
+		pq.QuoteIdentifier(name)))
+
+	return err
+}
+
+// DropDatabase drops the specified database (if it exists)
+func (drv *Driver) DropDatabase() error {
+	name := dbutil.DatabaseName(drv.databaseURL)
+	fmt.Printf("Dropping: %s\n", name)
+
+	db, err := drv.openPostgresDB()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	_, err = db.Exec(fmt.Sprintf("drop database if exists %s",
+		pq.QuoteIdentifier(name)))
+
+	return err
+}
+
+func (drv *Driver) schemaMigrationsDump(db *sql.DB) ([]byte, error) {
+	migrationsTable, err := drv.quotedMigrationsTableName(db)
+	if err != nil {
+		return nil, err
+	}
+
+	// load applied migrations
+	migrations, err := dbutil.QueryColumn(db,
+		"select quote_literal(version) from "+migrationsTable+" order by version asc")
+	if err != nil {
+		return nil, err
+	}
+
+	// build migrations table data
+	var buf bytes.Buffer
+	buf.WriteString("\n--\n-- Dbmate schema migrations\n--\n\n")
+
+	if len(migrations) > 0 {
+		buf.WriteString("INSERT INTO " + migrationsTable + " (version) VALUES\n    (" +
+			strings.Join(migrations, "),\n    (") +
+			");\n")
+	}
+
+	return buf.Bytes(), nil
+}
+
+// DumpSchema returns the current database schema
+func (drv *Driver) DumpSchema(db *sql.DB) ([]byte, error) {
+	// load schema
+	args := append([]string{"--format=plain", "--encoding=UTF8", "--schema-only",
+		"--no-privileges", "--no-owner"}, connectionArgsForDump(drv.databaseURL)...)
+	schema, err := dbutil.RunCommand("pg_dump", args...)
+	if err != nil {
+		return nil, err
+	}
+
+	migrations, err := drv.schemaMigrationsDump(db)
+	if err != nil {
+		return nil, err
+	}
+
+	schema = append(schema, migrations...)
+	return dbutil.TrimLeadingSQLComments(schema)
+}
+
+// DatabaseExists determines whether the database exists
+func (drv *Driver) DatabaseExists() (bool, error) {
+	name := dbutil.DatabaseName(drv.databaseURL)
+
+	db, err := drv.openPostgresDB()
+	if err != nil {
+		return false, err
+	}
+	defer dbutil.MustClose(db)
+
+	exists := false
+	err = db.QueryRow("select true from pg_database where datname = $1", name).
+		Scan(&exists)
+	if err == sql.ErrNoRows {
+		return false, nil
+	}
+
+	return exists, err
+}
+
+// CreateMigrationsTable creates the schema_migrations table
+func (drv *Driver) CreateMigrationsTable(db *sql.DB) error {
+	schema, migrationsTable, err := drv.quotedMigrationsTableNameParts(db)
+	if err != nil {
+		return err
+	}
+
+	// first attempt at creating migrations table
+	createTableStmt := fmt.Sprintf("create table if not exists %s.%s", schema, migrationsTable) +
+		" (version varchar(255) primary key)"
+	_, err = db.Exec(createTableStmt)
+	if err == nil {
+		// table exists or created successfully
+		return nil
+	}
+
+	// catch 'schema does not exist' error
+	pqErr, ok := err.(*pq.Error)
+	if !ok || pqErr.Code != "3F000" {
+		// unknown error
+		return err
+	}
+
+	// in theory we could attempt to create the schema every time, but we avoid that
+	// in case the user doesn't have permissions to create schemas
+	fmt.Printf("Creating schema: %s\n", schema)
+	_, err = db.Exec(fmt.Sprintf("create schema if not exists %s", schema))
+	if err != nil {
+		return err
+	}
+
+	// second and final attempt at creating migrations table
+	_, err = db.Exec(createTableStmt)
+	return err
+}
+
+// SelectMigrations returns a list of applied migrations
+// with an optional limit (in descending order)
+func (drv *Driver) SelectMigrations(db *sql.DB, limit int) (map[string]bool, error) {
+	migrationsTable, err := drv.quotedMigrationsTableName(db)
+	if err != nil {
+		return nil, err
+	}
+
+	query := "select version from " + migrationsTable + " order by version desc"
+	if limit >= 0 {
+		query = fmt.Sprintf("%s limit %d", query, limit)
+	}
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer dbutil.MustClose(rows)
+
+	migrations := map[string]bool{}
+	for rows.Next() {
+		var version string
+		if err := rows.Scan(&version); err != nil {
+			return nil, err
+		}
+
+		migrations[version] = true
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return migrations, nil
+}
+
+// InsertMigration adds a new migration record
+func (drv *Driver) InsertMigration(db dbutil.Transaction, version string) error {
+	migrationsTable, err := drv.quotedMigrationsTableName(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = db.Exec("insert into "+migrationsTable+" (version) values ($1)", version)
+
+	return err
+}
+
+// DeleteMigration removes a migration record
+func (drv *Driver) DeleteMigration(db dbutil.Transaction, version string) error {
+	migrationsTable, err := drv.quotedMigrationsTableName(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = db.Exec("delete from "+migrationsTable+" where version = $1", version)
+
+	return err
+}
+
+// Ping verifies a connection to the database server. It does not verify whether the
+// specified database exists.
+func (drv *Driver) Ping() error {
+	// attempt connection to primary database, not "postgres" database
+	// to support servers with no "postgres" database
+	// (see https://github.com/amacneil/dbmate/issues/78)
+	db, err := drv.Open()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	err = db.Ping()
+	if err == nil {
+		return nil
+	}
+
+	// ignore 'database does not exist' error
+	pqErr, ok := err.(*pq.Error)
+	if ok && pqErr.Code == "3D000" {
+		return nil
+	}
+
+	return err
+}
+
+func (drv *Driver) quotedMigrationsTableName(db dbutil.Transaction) (string, error) {
+	schema, name, err := drv.quotedMigrationsTableNameParts(db)
+	if err != nil {
+		return "", err
+	}
+
+	return schema + "." + name, nil
+}
+
+func (drv *Driver) quotedMigrationsTableNameParts(db dbutil.Transaction) (string, string, error) {
+	schema := ""
+	tableNameParts := strings.Split(drv.migrationsTableName, ".")
+	if len(tableNameParts) > 1 {
+		// schema specified as part of table name
+		schema, tableNameParts = tableNameParts[0], tableNameParts[1:]
+	}
+
+	if schema == "" {
+		// no schema specified with table name, try URL search path if available
+		searchPath := strings.Split(drv.databaseURL.Query().Get("search_path"), ",")
+		schema = strings.TrimSpace(searchPath[0])
+	}
+
+	var err error
+	if schema == "" {
+		// if no URL available, use current schema
+		// this is a hack because we don't always have the URL context available
+		schema, err = dbutil.QueryValue(db, "select current_schema()")
+		if err != nil {
+			return "", "", err
+		}
+	}
+
+	// fall back to public schema as last resort
+	if schema == "" {
+		schema = "public"
+	}
+
+	// quote all parts
+	// use server rather than client to do this to avoid unnecessary quotes
+	// (which would change schema.sql diff)
+	tableNameParts = append([]string{schema}, tableNameParts...)
+	quotedNameParts, err := dbutil.QueryColumn(db, "select quote_ident(unnest($1::text[]))", pq.Array(tableNameParts))
+	if err != nil {
+		return "", "", err
+	}
+
+	// if more than one part, we already have a schema
+	return quotedNameParts[0], strings.Join(quotedNameParts[1:], "."), nil
+}

pkg/driver/postgres/postgres_test.go

@@ -0,0 +1,569 @@
+package postgres
+
+import (
+	"database/sql"
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/stretchr/testify/require"
+)
+
+func testPostgresDriver(t *testing.T) *Driver {
+	u := dbutil.MustParseURL(os.Getenv("POSTGRES_TEST_URL"))
+	drv, err := dbmate.New(u).GetDriver()
+	require.NoError(t, err)
+
+	return drv.(*Driver)
+}
+
+func prepTestPostgresDB(t *testing.T) *sql.DB {
+	drv := testPostgresDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// connect database
+	db, err := sql.Open("postgres", drv.databaseURL.String())
+	require.NoError(t, err)
+
+	return db
+}
+
+func TestGetDriver(t *testing.T) {
+	db := dbmate.New(dbutil.MustParseURL("postgres://"))
+	drvInterface, err := db.GetDriver()
+	require.NoError(t, err)
+
+	// driver should have URL and default migrations table set
+	drv, ok := drvInterface.(*Driver)
+	require.True(t, ok)
+	require.Equal(t, db.DatabaseURL.String(), drv.databaseURL.String())
+	require.Equal(t, "schema_migrations", drv.migrationsTableName)
+}
+
+func TestConnectionString(t *testing.T) {
+	cases := []struct {
+		input    string
+		expected string
+	}{
+		// defaults
+		{"postgres:///foo", "postgres://localhost:5432/foo"},
+		// support custom url params
+		{"postgres://bob:secret@myhost:1234/foo?bar=baz", "postgres://bob:secret@myhost:1234/foo?bar=baz"},
+		// support `host` and `port` via url params
+		{"postgres://bob:secret@myhost:1234/foo?host=new&port=9999", "postgres://bob:secret@:9999/foo?host=new"},
+		{"postgres://bob:secret@myhost:1234/foo?port=9999&bar=baz", "postgres://bob:secret@myhost:9999/foo?bar=baz"},
+		// support unix sockets via `host` or `socket` param
+		{"postgres://bob:secret@myhost:1234/foo?host=/var/run/postgresql", "postgres://bob:secret@:1234/foo?host=%2Fvar%2Frun%2Fpostgresql"},
+		{"postgres://bob:secret@localhost/foo?socket=/var/run/postgresql", "postgres://bob:secret@:5432/foo?host=%2Fvar%2Frun%2Fpostgresql"},
+		{"postgres:///foo?socket=/var/run/postgresql", "postgres://:5432/foo?host=%2Fvar%2Frun%2Fpostgresql"},
+	}
+
+	for _, c := range cases {
+		t.Run(c.input, func(t *testing.T) {
+			u, err := url.Parse(c.input)
+			require.NoError(t, err)
+
+			actual := connectionString(u)
+			require.Equal(t, c.expected, actual)
+		})
+	}
+}
+
+func TestConnectionArgsForDump(t *testing.T) {
+	cases := []struct {
+		input    string
+		expected []string
+	}{
+		// defaults
+		{"postgres:///foo", []string{"postgres://localhost:5432/foo"}},
+		// support single schema
+		{"postgres:///foo?search_path=foo", []string{"--schema", "foo", "postgres://localhost:5432/foo"}},
+		// support multiple schemas
+		{"postgres:///foo?search_path=foo,public", []string{"--schema", "foo", "--schema", "public", "postgres://localhost:5432/foo"}},
+	}
+
+	for _, c := range cases {
+		t.Run(c.input, func(t *testing.T) {
+			u, err := url.Parse(c.input)
+			require.NoError(t, err)
+
+			actual := connectionArgsForDump(u)
+			require.Equal(t, c.expected, actual)
+		})
+	}
+}
+
+func TestPostgresCreateDropDatabase(t *testing.T) {
+	drv := testPostgresDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// check that database exists and we can connect to it
+	func() {
+		db, err := sql.Open("postgres", drv.databaseURL.String())
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.NoError(t, err)
+	}()
+
+	// drop the database
+	err = drv.DropDatabase()
+	require.NoError(t, err)
+
+	// check that database no longer exists
+	func() {
+		db, err := sql.Open("postgres", drv.databaseURL.String())
+		require.NoError(t, err)
+		defer dbutil.MustClose(db)
+
+		err = db.Ping()
+		require.Error(t, err)
+		require.Equal(t, "pq: database \"dbmate_test\" does not exist", err.Error())
+	}()
+}
+
+func TestPostgresDumpSchema(t *testing.T) {
+	t.Run("default migrations table", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+
+		// prepare database
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+		err := drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// insert migration
+		err = drv.InsertMigration(db, "abc1")
+		require.NoError(t, err)
+		err = drv.InsertMigration(db, "abc2")
+		require.NoError(t, err)
+
+		// DumpSchema should return schema
+		schema, err := drv.DumpSchema(db)
+		require.NoError(t, err)
+		require.Contains(t, string(schema), "CREATE TABLE public.schema_migrations")
+		require.Contains(t, string(schema), "\n--\n"+
+			"-- PostgreSQL database dump complete\n"+
+			"--\n\n\n"+
+			"--\n"+
+			"-- Dbmate schema migrations\n"+
+			"--\n\n"+
+			"INSERT INTO public.schema_migrations (version) VALUES\n"+
+			"    ('abc1'),\n"+
+			"    ('abc2');\n")
+
+		// DumpSchema should return error if command fails
+		drv.databaseURL.Path = "/fakedb"
+		schema, err = drv.DumpSchema(db)
+		require.Nil(t, schema)
+		require.EqualError(t, err, "pg_dump: [archiver (db)] connection to database "+
+			"\"fakedb\" failed: FATAL:  database \"fakedb\" does not exist")
+	})
+
+	t.Run("custom migrations table with schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		drv.migrationsTableName = "camelSchema.testMigrations"
+
+		// prepare database
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+		err := drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// insert migration
+		err = drv.InsertMigration(db, "abc1")
+		require.NoError(t, err)
+		err = drv.InsertMigration(db, "abc2")
+		require.NoError(t, err)
+
+		// DumpSchema should return schema
+		schema, err := drv.DumpSchema(db)
+		require.NoError(t, err)
+		require.Contains(t, string(schema), "CREATE TABLE \"camelSchema\".\"testMigrations\"")
+		require.Contains(t, string(schema), "\n--\n"+
+			"-- PostgreSQL database dump complete\n"+
+			"--\n\n\n"+
+			"--\n"+
+			"-- Dbmate schema migrations\n"+
+			"--\n\n"+
+			"INSERT INTO \"camelSchema\".\"testMigrations\" (version) VALUES\n"+
+			"    ('abc1'),\n"+
+			"    ('abc2');\n")
+	})
+}
+
+func TestPostgresDatabaseExists(t *testing.T) {
+	drv := testPostgresDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return false
+	exists, err := drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, false, exists)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return true
+	exists, err = drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, true, exists)
+}
+
+func TestPostgresDatabaseExists_Error(t *testing.T) {
+	drv := testPostgresDriver(t)
+	drv.databaseURL.User = url.User("invalid")
+
+	exists, err := drv.DatabaseExists()
+	require.Error(t, err)
+	require.Equal(t, "pq: password authentication failed for user \"invalid\"", err.Error())
+	require.Equal(t, false, exists)
+}
+
+func TestPostgresCreateMigrationsTable(t *testing.T) {
+	t.Run("default schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		// migrations table should not exist
+		count := 0
+		err := db.QueryRow("select count(*) from public.schema_migrations").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"public.schema_migrations\" does not exist", err.Error())
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// migrations table should exist
+		err = db.QueryRow("select count(*) from public.schema_migrations").Scan(&count)
+		require.NoError(t, err)
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+
+	t.Run("custom search path", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		drv.migrationsTableName = "testMigrations"
+
+		u, err := url.Parse(drv.databaseURL.String() + "&search_path=camelFoo")
+		require.NoError(t, err)
+		drv.databaseURL = u
+
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		// delete schema
+		_, err = db.Exec("drop schema if exists \"camelFoo\"")
+		require.NoError(t, err)
+
+		// drop any testMigrations table in public schema
+		_, err = db.Exec("drop table if exists public.\"testMigrations\"")
+		require.NoError(t, err)
+
+		// migrations table should not exist in either schema
+		count := 0
+		err = db.QueryRow("select count(*) from \"camelFoo\".\"testMigrations\"").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"camelFoo.testMigrations\" does not exist", err.Error())
+		err = db.QueryRow("select count(*) from public.\"testMigrations\"").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"public.testMigrations\" does not exist", err.Error())
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// camelFoo schema should be created, and migrations table should exist only in camelFoo schema
+		err = db.QueryRow("select count(*) from \"camelFoo\".\"testMigrations\"").Scan(&count)
+		require.NoError(t, err)
+		err = db.QueryRow("select count(*) from public.\"testMigrations\"").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"public.testMigrations\" does not exist", err.Error())
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+
+	t.Run("custom schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		drv.migrationsTableName = "camelSchema.testMigrations"
+
+		u, err := url.Parse(drv.databaseURL.String() + "&search_path=foo")
+		require.NoError(t, err)
+		drv.databaseURL = u
+
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		// delete schemas
+		_, err = db.Exec("drop schema if exists foo")
+		require.NoError(t, err)
+		_, err = db.Exec("drop schema if exists \"camelSchema\"")
+		require.NoError(t, err)
+
+		// migrations table should not exist
+		count := 0
+		err = db.QueryRow("select count(*) from \"camelSchema\".\"testMigrations\"").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"camelSchema.testMigrations\" does not exist", err.Error())
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// camelSchema should be created, and testMigrations table should exist
+		err = db.QueryRow("select count(*) from \"camelSchema\".\"testMigrations\"").Scan(&count)
+		require.NoError(t, err)
+		// testMigrations table should not exist in foo schema because
+		// schema specified with migrations table name takes priority over search path
+		err = db.QueryRow("select count(*) from foo.\"testMigrations\"").Scan(&count)
+		require.Error(t, err)
+		require.Equal(t, "pq: relation \"foo.testMigrations\" does not exist", err.Error())
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+}
+
+func TestPostgresSelectMigrations(t *testing.T) {
+	drv := testPostgresDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestPostgresDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into public.test_migrations (version)
+		values ('abc2'), ('abc1'), ('abc3')`)
+	require.NoError(t, err)
+
+	migrations, err := drv.SelectMigrations(db, -1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc1"])
+	require.Equal(t, true, migrations["abc2"])
+	require.Equal(t, true, migrations["abc2"])
+
+	// test limit param
+	migrations, err = drv.SelectMigrations(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc3"])
+	require.Equal(t, false, migrations["abc1"])
+	require.Equal(t, false, migrations["abc2"])
+}
+
+func TestPostgresInsertMigration(t *testing.T) {
+	drv := testPostgresDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestPostgresDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from public.test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 0, count)
+
+	// insert migration
+	err = drv.InsertMigration(db, "abc1")
+	require.NoError(t, err)
+
+	err = db.QueryRow("select count(*) from public.test_migrations where version = 'abc1'").
+		Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestPostgresDeleteMigration(t *testing.T) {
+	drv := testPostgresDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestPostgresDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into public.test_migrations (version)
+		values ('abc1'), ('abc2')`)
+	require.NoError(t, err)
+
+	err = drv.DeleteMigration(db, "abc2")
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from public.test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestPostgresPing(t *testing.T) {
+	drv := testPostgresDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// ping database
+	err = drv.Ping()
+	require.NoError(t, err)
+
+	// ping invalid host should return error
+	drv.databaseURL.Host = "postgres:404"
+	err = drv.Ping()
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "connect: connection refused")
+}
+
+func TestPostgresQuotedMigrationsTableName(t *testing.T) {
+	t.Run("default schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "public.schema_migrations", name)
+	})
+
+	t.Run("custom schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		u, err := url.Parse(drv.databaseURL.String() + "&search_path=foo,bar,public")
+		require.NoError(t, err)
+		drv.databaseURL = u
+
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		_, err = db.Exec("drop schema if exists foo")
+		require.NoError(t, err)
+		_, err = db.Exec("drop schema if exists bar")
+		require.NoError(t, err)
+
+		// should use first schema from search path
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "foo.schema_migrations", name)
+	})
+
+	t.Run("no schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		// this is an unlikely edge case, but if for some reason there is
+		// no current schema then we should default to "public"
+		_, err := db.Exec("select pg_catalog.set_config('search_path', '', false)")
+		require.NoError(t, err)
+
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "public.schema_migrations", name)
+	})
+
+	t.Run("custom table name", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		drv.migrationsTableName = "simple_name"
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "public.simple_name", name)
+	})
+
+	t.Run("custom table name quoted", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		// this table name will need quoting
+		drv.migrationsTableName = "camelCase"
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "public.\"camelCase\"", name)
+	})
+
+	t.Run("custom table name with custom schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		u, err := url.Parse(drv.databaseURL.String() + "&search_path=foo")
+		require.NoError(t, err)
+		drv.databaseURL = u
+
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		_, err = db.Exec("create schema if not exists foo")
+		require.NoError(t, err)
+
+		drv.migrationsTableName = "simple_name"
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "foo.simple_name", name)
+	})
+
+	t.Run("custom table name overrides schema", func(t *testing.T) {
+		drv := testPostgresDriver(t)
+		u, err := url.Parse(drv.databaseURL.String() + "&search_path=foo")
+		require.NoError(t, err)
+		drv.databaseURL = u
+
+		db := prepTestPostgresDB(t)
+		defer dbutil.MustClose(db)
+
+		_, err = db.Exec("create schema if not exists foo")
+		require.NoError(t, err)
+		_, err = db.Exec("create schema if not exists bar")
+		require.NoError(t, err)
+
+		// if schema is specified as part of table name, it should override search_path
+		drv.migrationsTableName = "bar.simple_name"
+		name, err := drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "bar.simple_name", name)
+
+		// schema and table name should be quoted if necessary
+		drv.migrationsTableName = "barName.camelTable"
+		name, err = drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "\"barName\".\"camelTable\"", name)
+
+		// more than 2 components is unexpected but we will quote and pass it along anyway
+		drv.migrationsTableName = "whyWould.i.doThis"
+		name, err = drv.quotedMigrationsTableName(db)
+		require.NoError(t, err)
+		require.Equal(t, "\"whyWould\".i.\"doThis\"", name)
+	})
+}

pkg/driver/sqlite/sqlite.go

@@ -0,0 +1,220 @@
+// +build cgo
+
+package sqlite
+
+import (
+	"bytes"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/lib/pq"
+	_ "github.com/mattn/go-sqlite3" // database/sql driver
+)
+
+func init() {
+	dbmate.RegisterDriver(NewDriver, "sqlite")
+	dbmate.RegisterDriver(NewDriver, "sqlite3")
+}
+
+// Driver provides top level database functions
+type Driver struct {
+	migrationsTableName string
+	databaseURL         *url.URL
+}
+
+// NewDriver initializes the driver
+func NewDriver(config dbmate.DriverConfig) dbmate.Driver {
+	return &Driver{
+		migrationsTableName: config.MigrationsTableName,
+		databaseURL:         config.DatabaseURL,
+	}
+}
+
+// ConnectionString converts a URL into a valid connection string
+func ConnectionString(u *url.URL) string {
+	// duplicate URL and remove scheme
+	newURL := *u
+	newURL.Scheme = ""
+
+	// trim duplicate leading slashes
+	str := regexp.MustCompile("^//+").ReplaceAllString(newURL.String(), "/")
+
+	return str
+}
+
+// Open creates a new database connection
+func (drv *Driver) Open() (*sql.DB, error) {
+	return sql.Open("sqlite3", ConnectionString(drv.databaseURL))
+}
+
+// CreateDatabase creates the specified database
+func (drv *Driver) CreateDatabase() error {
+	fmt.Printf("Creating: %s\n", ConnectionString(drv.databaseURL))
+
+	db, err := drv.Open()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	return db.Ping()
+}
+
+// DropDatabase drops the specified database (if it exists)
+func (drv *Driver) DropDatabase() error {
+	path := ConnectionString(drv.databaseURL)
+	fmt.Printf("Dropping: %s\n", path)
+
+	exists, err := drv.DatabaseExists()
+	if err != nil {
+		return err
+	}
+	if !exists {
+		return nil
+	}
+
+	return os.Remove(path)
+}
+
+func (drv *Driver) schemaMigrationsDump(db *sql.DB) ([]byte, error) {
+	migrationsTable := drv.quotedMigrationsTableName()
+
+	// load applied migrations
+	migrations, err := dbutil.QueryColumn(db,
+		fmt.Sprintf("select quote(version) from %s order by version asc", migrationsTable))
+	if err != nil {
+		return nil, err
+	}
+
+	// build schema migrations table data
+	var buf bytes.Buffer
+	buf.WriteString("-- Dbmate schema migrations\n")
+
+	if len(migrations) > 0 {
+		buf.WriteString(
+			fmt.Sprintf("INSERT INTO %s (version) VALUES\n  (", migrationsTable) +
+				strings.Join(migrations, "),\n  (") +
+				");\n")
+	}
+
+	return buf.Bytes(), nil
+}
+
+// DumpSchema returns the current database schema
+func (drv *Driver) DumpSchema(db *sql.DB) ([]byte, error) {
+	path := ConnectionString(drv.databaseURL)
+	schema, err := dbutil.RunCommand("sqlite3", path, ".schema")
+	if err != nil {
+		return nil, err
+	}
+
+	migrations, err := drv.schemaMigrationsDump(db)
+	if err != nil {
+		return nil, err
+	}
+
+	schema = append(schema, migrations...)
+	return dbutil.TrimLeadingSQLComments(schema)
+}
+
+// DatabaseExists determines whether the database exists
+func (drv *Driver) DatabaseExists() (bool, error) {
+	_, err := os.Stat(ConnectionString(drv.databaseURL))
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+// CreateMigrationsTable creates the schema migrations table
+func (drv *Driver) CreateMigrationsTable(db *sql.DB) error {
+	_, err := db.Exec(
+		fmt.Sprintf("create table if not exists %s ", drv.quotedMigrationsTableName()) +
+			"(version varchar(255) primary key)")
+
+	return err
+}
+
+// SelectMigrations returns a list of applied migrations
+// with an optional limit (in descending order)
+func (drv *Driver) SelectMigrations(db *sql.DB, limit int) (map[string]bool, error) {
+	query := fmt.Sprintf("select version from %s order by version desc", drv.quotedMigrationsTableName())
+	if limit >= 0 {
+		query = fmt.Sprintf("%s limit %d", query, limit)
+	}
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer dbutil.MustClose(rows)
+
+	migrations := map[string]bool{}
+	for rows.Next() {
+		var version string
+		if err := rows.Scan(&version); err != nil {
+			return nil, err
+		}
+
+		migrations[version] = true
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return migrations, nil
+}
+
+// InsertMigration adds a new migration record
+func (drv *Driver) InsertMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("insert into %s (version) values (?)", drv.quotedMigrationsTableName()),
+		version)
+
+	return err
+}
+
+// DeleteMigration removes a migration record
+func (drv *Driver) DeleteMigration(db dbutil.Transaction, version string) error {
+	_, err := db.Exec(
+		fmt.Sprintf("delete from %s where version = ?", drv.quotedMigrationsTableName()),
+		version)
+
+	return err
+}
+
+// Ping verifies a connection to the database. Due to the way SQLite works, by
+// testing whether the database is valid, it will automatically create the database
+// if it does not already exist.
+func (drv *Driver) Ping() error {
+	db, err := drv.Open()
+	if err != nil {
+		return err
+	}
+	defer dbutil.MustClose(db)
+
+	return db.Ping()
+}
+
+func (drv *Driver) quotedMigrationsTableName() string {
+	return drv.quoteIdentifier(drv.migrationsTableName)
+}
+
+// quoteIdentifier quotes a table or column name
+// we fall back to lib/pq implementation since both use ansi standard (double quotes)
+// and mattn/go-sqlite3 doesn't provide a sqlite-specific equivalent
+func (drv *Driver) quoteIdentifier(s string) string {
+	return pq.QuoteIdentifier(s)
+}

pkg/driver/sqlite/sqlite_test.go

@@ -0,0 +1,336 @@
+// +build cgo
+
+package sqlite
+
+import (
+	"database/sql"
+	"os"
+	"testing"
+
+	"github.com/amacneil/dbmate/pkg/dbmate"
+	"github.com/amacneil/dbmate/pkg/dbutil"
+
+	"github.com/stretchr/testify/require"
+)
+
+func testSQLiteDriver(t *testing.T) *Driver {
+	u := dbutil.MustParseURL(os.Getenv("SQLITE_TEST_URL"))
+	drv, err := dbmate.New(u).GetDriver()
+	require.NoError(t, err)
+
+	return drv.(*Driver)
+}
+
+func prepTestSQLiteDB(t *testing.T) *sql.DB {
+	drv := testSQLiteDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// connect database
+	db, err := drv.Open()
+	require.NoError(t, err)
+
+	return db
+}
+
+func TestGetDriver(t *testing.T) {
+	db := dbmate.New(dbutil.MustParseURL("sqlite://"))
+	drvInterface, err := db.GetDriver()
+	require.NoError(t, err)
+
+	// driver should have URL and default migrations table set
+	drv, ok := drvInterface.(*Driver)
+	require.True(t, ok)
+	require.Equal(t, db.DatabaseURL.String(), drv.databaseURL.String())
+	require.Equal(t, "schema_migrations", drv.migrationsTableName)
+}
+
+func TestConnectionString(t *testing.T) {
+	t.Run("relative", func(t *testing.T) {
+		u := dbutil.MustParseURL("sqlite:foo/bar.sqlite3?mode=ro")
+		require.Equal(t, "foo/bar.sqlite3?mode=ro", ConnectionString(u))
+	})
+
+	t.Run("absolute", func(t *testing.T) {
+		u := dbutil.MustParseURL("sqlite:/tmp/foo.sqlite3?mode=ro")
+		require.Equal(t, "/tmp/foo.sqlite3?mode=ro", ConnectionString(u))
+	})
+
+	t.Run("three slashes", func(t *testing.T) {
+		// interpreted as absolute path
+		u := dbutil.MustParseURL("sqlite:///tmp/foo.sqlite3?mode=ro")
+		require.Equal(t, "/tmp/foo.sqlite3?mode=ro", ConnectionString(u))
+	})
+
+	t.Run("four slashes", func(t *testing.T) {
+		// interpreted as absolute path
+		// supported for backwards compatibility
+		u := dbutil.MustParseURL("sqlite:////tmp/foo.sqlite3?mode=ro")
+		require.Equal(t, "/tmp/foo.sqlite3?mode=ro", ConnectionString(u))
+	})
+}
+
+func TestSQLiteCreateDropDatabase(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	path := ConnectionString(drv.databaseURL)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// check that database exists
+	_, err = os.Stat(path)
+	require.NoError(t, err)
+
+	// drop the database
+	err = drv.DropDatabase()
+	require.NoError(t, err)
+
+	// check that database no longer exists
+	_, err = os.Stat(path)
+	require.NotNil(t, err)
+	require.Equal(t, true, os.IsNotExist(err))
+}
+
+func TestSQLiteDumpSchema(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	// prepare database
+	db := prepTestSQLiteDB(t)
+	defer dbutil.MustClose(db)
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	// insert migration
+	err = drv.InsertMigration(db, "abc1")
+	require.NoError(t, err)
+	err = drv.InsertMigration(db, "abc2")
+	require.NoError(t, err)
+
+	// DumpSchema should return schema
+	schema, err := drv.DumpSchema(db)
+	require.NoError(t, err)
+	require.Contains(t, string(schema), "CREATE TABLE IF NOT EXISTS \"test_migrations\"")
+	require.Contains(t, string(schema), ");\n-- Dbmate schema migrations\n"+
+		"INSERT INTO \"test_migrations\" (version) VALUES\n"+
+		"  ('abc1'),\n"+
+		"  ('abc2');\n")
+
+	// DumpSchema should return error if command fails
+	drv.databaseURL = dbutil.MustParseURL(".")
+	schema, err = drv.DumpSchema(db)
+	require.Nil(t, schema)
+	require.Error(t, err)
+	require.EqualError(t, err, "Error: unable to open database \".\": "+
+		"unable to open database file")
+}
+
+func TestSQLiteDatabaseExists(t *testing.T) {
+	drv := testSQLiteDriver(t)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return false
+	exists, err := drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, false, exists)
+
+	// create database
+	err = drv.CreateDatabase()
+	require.NoError(t, err)
+
+	// DatabaseExists should return true
+	exists, err = drv.DatabaseExists()
+	require.NoError(t, err)
+	require.Equal(t, true, exists)
+}
+
+func TestSQLiteCreateMigrationsTable(t *testing.T) {
+	t.Run("default table", func(t *testing.T) {
+		drv := testSQLiteDriver(t)
+		db := prepTestSQLiteDB(t)
+		defer dbutil.MustClose(db)
+
+		// migrations table should not exist
+		count := 0
+		err := db.QueryRow("select count(*) from schema_migrations").Scan(&count)
+		require.Error(t, err)
+		require.Regexp(t, "no such table: schema_migrations", err.Error())
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// migrations table should exist
+		err = db.QueryRow("select count(*) from schema_migrations").Scan(&count)
+		require.NoError(t, err)
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+
+	t.Run("custom table", func(t *testing.T) {
+		drv := testSQLiteDriver(t)
+		drv.migrationsTableName = "test_migrations"
+
+		db := prepTestSQLiteDB(t)
+		defer dbutil.MustClose(db)
+
+		// migrations table should not exist
+		count := 0
+		err := db.QueryRow("select count(*) from test_migrations").Scan(&count)
+		require.Error(t, err)
+		require.Regexp(t, "no such table: test_migrations", err.Error())
+
+		// create table
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+
+		// migrations table should exist
+		err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+		require.NoError(t, err)
+
+		// create table should be idempotent
+		err = drv.CreateMigrationsTable(db)
+		require.NoError(t, err)
+	})
+}
+
+func TestSQLiteSelectMigrations(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestSQLiteDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into test_migrations (version)
+		values ('abc2'), ('abc1'), ('abc3')`)
+	require.NoError(t, err)
+
+	migrations, err := drv.SelectMigrations(db, -1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc1"])
+	require.Equal(t, true, migrations["abc2"])
+	require.Equal(t, true, migrations["abc2"])
+
+	// test limit param
+	migrations, err = drv.SelectMigrations(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, true, migrations["abc3"])
+	require.Equal(t, false, migrations["abc1"])
+	require.Equal(t, false, migrations["abc2"])
+}
+
+func TestSQLiteInsertMigration(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestSQLiteDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 0, count)
+
+	// insert migration
+	err = drv.InsertMigration(db, "abc1")
+	require.NoError(t, err)
+
+	err = db.QueryRow("select count(*) from test_migrations where version = 'abc1'").
+		Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestSQLiteDeleteMigration(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	drv.migrationsTableName = "test_migrations"
+
+	db := prepTestSQLiteDB(t)
+	defer dbutil.MustClose(db)
+
+	err := drv.CreateMigrationsTable(db)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`insert into test_migrations (version)
+		values ('abc1'), ('abc2')`)
+	require.NoError(t, err)
+
+	err = drv.DeleteMigration(db, "abc2")
+	require.NoError(t, err)
+
+	count := 0
+	err = db.QueryRow("select count(*) from test_migrations").Scan(&count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
+}
+
+func TestSQLitePing(t *testing.T) {
+	drv := testSQLiteDriver(t)
+	path := ConnectionString(drv.databaseURL)
+
+	// drop any existing database
+	err := drv.DropDatabase()
+	require.NoError(t, err)
+
+	// ping database
+	err = drv.Ping()
+	require.NoError(t, err)
+
+	// check that the database was created (sqlite-only behavior)
+	_, err = os.Stat(path)
+	require.NoError(t, err)
+
+	// drop the database
+	err = drv.DropDatabase()
+	require.NoError(t, err)
+
+	// create directory where database file is expected
+	err = os.Mkdir(path, 0755)
+	require.NoError(t, err)
+	defer func() {
+		err = os.RemoveAll(path)
+		require.NoError(t, err)
+	}()
+
+	// ping database should fail
+	err = drv.Ping()
+	require.EqualError(t, err, "unable to open database file: is a directory")
+}
+
+func TestSQLiteQuotedMigrationsTableName(t *testing.T) {
+	t.Run("default name", func(t *testing.T) {
+		drv := testSQLiteDriver(t)
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, `"schema_migrations"`, name)
+	})
+
+	t.Run("custom name", func(t *testing.T) {
+		drv := testSQLiteDriver(t)
+		drv.migrationsTableName = "fooMigrations"
+
+		name := drv.quotedMigrationsTableName()
+		require.Equal(t, `"fooMigrations"`, name)
+	})
+}