Support Go 1.11 and drop support for Go 1.9

- Support modules in Go 1.11

.dockerignore

@@ -0,0 +1,13 @@
+# Project
+FAQ.md
+README.md
+LICENSE
+Makefile
+.gitignore
+.travis.yml
+CONTRIBUTING.md
+MIGRATIONS.md
+docker-deploy.sh
+
+# Golang
+testing

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,35 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the Bug**
+A clear and concise description of what the bug is.
+
+**Steps to Reproduce**
+Steps to reproduce the behavior:
+1. My migrations look like '...'
+2. I ran migrate with the following options '....'
+3. See error
+
+**Expected Behavior**
+A clear and concise description of what you expected to happen.
+
+**Migrate Version**
+e.g. v3.4.0
+Obtained by running: `migrate -version`
+
+**Loaded Source Drivers**
+e.g. s3, github, go-bindata, gcs, file
+Obtained by running: `migrate -help`
+
+**Loaded Database Drivers**
+e.g. spanner, stub, clickhouse, cockroachdb, crdb-postgres, postgres, postgresql, redshift, cassandra, cockroach, mysql
+Obtained by running: `migrate -help`
+
+**Stacktrace**
+Please provide if available
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -4,3 +4,4 @@ cli/cli
 cli/migrate
 .coverage
 .godoc.pid
+vendor/

.travis.yml

@@ -2,43 +2,61 @@ language: go
 sudo: required
 
 go:
-  - 1.7
-  - 1.8
+  - "1.10.x"
+  - "1.11.x"
+
+go_import_path: github.com/golang-migrate/migrate
 
 env:
-  - MIGRATE_TEST_CONTAINER_BOOT_DELAY=10
+  global:
+    - GO111MODULE=on
+    - MIGRATE_TEST_CONTAINER_BOOT_TIMEOUT=60
+    - DOCKER_USERNAME=golangmigrate
+    -   secure: "oSOznzUrgr5h45qW4PONkREpisPAt40tnM+KFWtS/Ggu5UI2Ie0CmyYXWuBjbt7B97a4yN9Qzmn8FxJHJ7kk+ABOi3muhkxeIhr6esXbzHhX/Jhv0mj1xkzX7KoVN9oHBz3cOI/QeRyEAO68xjDHNE2kby4RTT9VBt6TQUakKVkqI5qkqLBTADepCjVC+9XhxVxUNyeWKU8ormaUfJBjoNVoDlwXekUPnJenfmfZqXxUInvBCfUyp7Pq+kurBORmg4yc6qOlRYuK67Xw+i5xpjbZouNlXPk0rq7pPy5zjhmZQ3kImoFPvNMeKViDcI6kSIJKtjdhms9/g/6MgXS9HlL5kFy8tYKbsyiHnHB1BsvaLAKXctbUZFDPstgMPADfnad2kZXPrNqIhfWKZrGRWidawCYJ1sKKwYxLMKrtA0umqgMoL90MmBOELhuGmvMV0cFJB+zo+K2YWjEiMGd8xRb5mC5aAy0ZcCehO46jGtpr217EJmMF8Ywr7cFqM2Shg5U2jev9qUpYiXwmPnJKDuoT2ZHuHmPgFIkYiWC5yeJnnmG5bed1sKBp93AFrJX+1Rx5oC4BpNegewmBZKpOSwls/D1uMAeQK3dPmQHLsT6o2VBLfeDGr+zY0R85ywwPZCv00vGol02zYoTqN7eFqr6Qhjr/qx5K1nnxJdFK3Ts="
 
-# TODO: https://docs.docker.com/engine/installation/linux/ubuntu/    
-# pre-provision with travis docker setup and pin down docker version in install step
 services:
-  - docker 
+  - docker
+
+before_cache:
+  - mv $GOPATH/src/github.com/golang-migrate /tmp/golang-migrate
+  - rm -rf $GOPATH/pkg/**/github.com/golang-migrate
+
+cache:
+  directories:
+    - $GOPATH/pkg
+
+before_install:
+  - echo "TRAVIS_GO_VERSION=${TRAVIS_GO_VERSION}"
+  # Download the binary to bin folder in $GOPATH
+  - if [[ "${TRAVIS_GO_VERSION}" == 1.10* ]]; then curl -L -s https://github.com/golang/dep/releases/download/v0.5.0/dep-linux-amd64 -o $GOPATH/bin/dep; fi
+  # Make the binary executable
+  - if [[ "${TRAVIS_GO_VERSION}" == 1.10* ]]; then chmod +x $GOPATH/bin/dep; fi
 
 install:
-  - make deps
-  - (cd $GOPATH/src/github.com/docker/docker && git fetch --all --tags --prune && git checkout v1.13.0)
-  - sudo apt-get update && sudo apt-get install docker-engine=1.13.0*
-  - go get github.com/mattn/goveralls 
+  - if [[ "${TRAVIS_GO_VERSION}" == 1.10* ]]; then dep ensure -vendor-only; fi
+  - go get github.com/mattn/goveralls
 
 script:
-  - make test
+  - make test COVERAGE_DIR=/tmp/coverage
 
 after_success:
-  - goveralls -service=travis-ci -coverprofile .coverage/combined.txt
+  - mv /tmp/golang-migrate $GOPATH/src/github.com/golang-migrate
+  - goveralls -service=travis-ci -coverprofile /tmp/coverage/combined.txt
   - make list-external-deps > dependency_tree.txt && cat dependency_tree.txt
 
 before_deploy:
   - make build-cli
   - gem install --no-ri --no-rdoc fpm 
-  - fpm -s dir -t deb -n migrate -v "$(git describe --tags 2>/dev/null | cut -c 2-)" --license MIT -m matthias.kadenbach@gmail.com --url https://github.com/mattes/migrate --description='Database migrations' -a amd64 -p migrate.$(git describe --tags 2>/dev/null | cut -c 2-).deb --deb-no-default-config-files -f -C cli/build migrate.linux-amd64=/usr/bin/migrate
+  - fpm -s dir -t deb -n migrate -v "$(git describe --tags 2>/dev/null | cut -c 2-)" --license MIT -m dhui@users.noreply.github.com --url https://github.com/golang-migrate/migrate --description='Database migrations' -a amd64 -p migrate.$(git describe --tags 2>/dev/null | cut -c 2-).deb --deb-no-default-config-files -f -C cli/build migrate.linux-amd64=/usr/bin/migrate
 
 deploy:
   - provider: releases
     api_key:
-      secure: EFow50BI448HVb/uQ1Kk2Kq0xzmwIYq3V67YyymXIuqSCodvXEsMiBPUoLrxEknpPEIc67LEQTNdfHBgvyHk6oRINWAfie+7pr5tKrpOTF9ghyxoN1PlO8WKQCqwCvGMBCnc5ur5rvzp0bqfpV2rs5q9/nngy3kBuEvs12V7iho=
+      secure: hWH1HLPpzpfA8pXQ93T1qKQVFSpQp0as/JLQ7D91jHuJ8p+RxVeqblDrR6HQY/95R/nyiE9GJmvUolSuw5h449LSrGxPtVWhdh6EnkxlQHlen5XeMhVjRjFV0sE9qGe8v7uAkiTfRO61ktTWHrEAvw5qpyqnNISodmZS78XIasPODQbNlzwINhWhDTHIjXGb4FpizYaL3OGCanrxfR9fQyCaqKGGBjRq3Mfq8U6Yd4mApmsE+uJxgaZV8K5zBqpkSzQRWhcVGNL5DuLsU3gfSJOo7kZeA2G71SHffH577dBoqtCZ4VFv169CoUZehLWCb+7XKJZmHXVujCURATSySLGUOPc6EoLFAn3YtsCA04mS4bZVo5FZPWVwfhjmkhtDR4f6wscKp7r1HsFHSOgm59QfETQdrn4MnZ44H2Jd39axqndn5DvK9EcZVjPHynOPnueXP2u6mTuUgh2VyyWBCDO3CNo0fGlo7VJI69IkIWNSD87K9cHZWYMClyKZkUzS+PmRAhHRYbVd+9ZjKOmnU36kUHNDG/ft1D4ogsY+rhVtXB4lgWDM5adri+EIScYdYnB1/pQexLBigcJY9uE7nQTR0U6QgVNYvun7uRNs40E0c4voSfmPdFO0FlOD2y1oQhnaXfWLbu9nMcTcs4RFGrcC7NzkUN4/WjG8s285V6w=
     skip_cleanup: true
     on:
-      go: 1.8
-      repo: mattes/migrate
+      go: "1.11.x"
+      repo: golang-migrate/migrate
       tags: true
     file:
       - cli/build/migrate.linux-amd64.tar.gz
@@ -48,14 +66,19 @@ deploy:
       - dependency_tree.txt
   - provider: packagecloud
     repository: migrate
-    username: mattes
+    username: golang-migrate
     token:
-      secure: RiHJ/+J9DvXUah/APYdWySWZ5uOOISYJ0wS7xddc7/BNStRVjzFzvJ9zmb67RkyZZrvGuVjPiL4T8mtDyCJCj47RmU/56wPdEHbar/FjsiUCgwvR19RlulkgbV4okBCePbwzMw6HNHRp14TzfQCPtnN4kef0lOI4gZJkImN7rtQ=
+      secure: aICwu3gJ1sJ1QVCD3elpg+Jxzt4P+Zj1uoh5f0sOwnjDNIZ4FwUT1cMrWloP8P2KD0iyCOawuZER27o/kQ21oX2OxHvQbYPReA2znLm7lHzCmypAAOHPxpgnQ4rMGHHJXd+OsxtdclGs67c+EbdBfoRRbK400Qz/vjPJEDeH4mh02ZHC2nw4Nk/wV4jjBIkIt9dGEx6NgOA17FCMa3MaPHlHeFIzU7IfTlDHbS0mCCYbg/wafWBWcbGqtZLWAYtJDmfjrAStmDLdAX5J5PsB7taGSGPZHmPmpGoVgrKt/tb9Xz1rFBGslTpGROOiO4CiMAvkEKFn8mxrBGjfSBqp7Dp3eeSalKXB1DJAbEXx2sEbMcvmnoR9o43meaAn+ZRts8lRL8S/skBloe6Nk8bx3NlJCGB9WPK1G56b7c/fZnJxQbrCw6hxDfbZwm8S2YPviFTo/z1BfZDhRsL74reKsN2kgnGo2W/k38vvzIpsssQ9DHN1b0TLCxolCNPtQ7oHcQ1ohcjP2UgYXk0FhqDoL+9LQva/DU4N9sKH0UbAaqsMVSErLeG8A4aauuFcVrWRBaDYyTag4dQqzTulEy7iru2kDDIBgSQ1gMW/yoBOIPK4oi6MtbTf1X39fzXFLS1cDd3LW61yAu3YrbjAetpfx2frIvrRAiL9TxWA1gnrs5o=
     dist: ubuntu/xenial
     package_glob: '*.deb'
     skip_cleanup: true
     on:
-      go: 1.8
-      repo: mattes/migrate
+      go: "1.11.x"
+      repo: golang-migrate/migrate
+      tags: true
+  - provider: script
+    script: ./docker-deploy.sh
+    on:
+      go: "1.11.x"
+      repo: golang-migrate/migrate
       tags: true
-

CONTRIBUTING.md

@@ -2,21 +2,20 @@
 
   1. Make sure you have a running Docker daemon
      (Install for [MacOS](https://docs.docker.com/docker-for-mac/))
-  2. Fork this repo and `git clone` somewhere to `$GOPATH/src/github.com/%you%/migrate`
-  3. `make rewrite-import-paths` to update imports to your local fork
-  4. Confirm tests are working: `make test-short`
-  5. Write awesome code ...
-  6. `make test` to run all tests against all database versions
-  7. `make restore-import-paths` to restore import paths
-  8. Push code and open Pull Request
+  1. Fork this repo and `git clone` somewhere to `$GOPATH/src/github.com/golang-migrate/migrate`
+  1. Install [dep](https://github.com/golang/dep) and run `dep ensure` to pull dependencies
+  1. Confirm tests are working: `make test-short`
+  1. Write awesome code ...
+  1. `make test` to run all tests against all database versions
+  1. Push code and open Pull Request
  
 Some more helpful commands:
 
-  * You can specify which database/ source tests to run:  
-    `make test-short SOURCE='file go-bindata' DATABASE='postgres cassandra'`
-  * After `make test`, run `make html-coverage` which opens a shiny test coverage overview.  
-  * Missing imports? `make deps`
+  * You can specify which database/ source tests to run:
+    `make test-short SOURCE='file go_bindata' DATABASE='postgres cassandra'`
+  * After `make test`, run `make html-coverage` which opens a shiny test coverage overview.
   * `make build-cli` builds the CLI in directory `cli/build/`.
   * `make list-external-deps` lists all external dependencies for each package
-  * `make docs && make open-docs` opens godoc in your browser, `make kill-docs` kills the godoc server.  
-    Repeatedly call `make docs` to refresh the server.  
+  * `make docs && make open-docs` opens godoc in your browser, `make kill-docs` kills the godoc server.
+    Repeatedly call `make docs` to refresh the server.
+  * Set the `DOCKER_API_VERSION` environment variable to the latest supported version if you get errors regarding the docker client API version being too new.

Dockerfile

@@ -0,0 +1,30 @@
+FROM golang:1.10-alpine3.7 AS downloader
+ARG VERSION
+
+RUN apk add --no-cache git gcc musl-dev curl
+
+RUN curl -fsSL -o /usr/local/bin/dep https://github.com/golang/dep/releases/download/v0.4.1/dep-linux-amd64 && chmod +x /usr/local/bin/dep
+
+WORKDIR /go/src/github.com/golang-migrate/migrate
+
+COPY Gopkg.toml Gopkg.lock ./
+RUN dep ensure -vendor-only
+
+COPY *.go ./
+COPY cli ./cli
+COPY database ./database
+COPY source ./source
+
+ENV DATABASES="postgres mysql redshift cassandra spanner cockroachdb clickhouse"
+ENV SOURCES="file go_bindata github aws_s3 google_cloud_storage"
+
+RUN go build -a -o build/migrate.linux-386 -ldflags="-X main.Version=${VERSION}" -tags "$DATABASES $SOURCES" ./cli
+
+FROM alpine:3.7
+
+RUN apk add --no-cache ca-certificates
+
+COPY --from=downloader /go/src/github.com/golang-migrate/migrate/build/migrate.linux-386 /migrate
+
+ENTRYPOINT ["/migrate"]
+CMD ["--help"]

FAQ.md

@@ -1,67 +1,67 @@
-# FAQ
-
-#### How is the code base structured?
-  ```
-  /          package migrate (the heart of everything)
-  /cli       the CLI wrapper
-  /database  database driver and sub directories have the actual driver implementations
-  /source    source driver and sub directories have the actual driver implementations
-  ```
-
-#### Why is there no `source/driver.go:Last()`?
-  It's not needed. And unless the source has a "native" way to read a directory in reversed order,
-  it might be expensive to do a full directory scan in order to get the last element.
-
-#### What is a NilMigration? NilVersion?
-  NilMigration defines a migration without a body. NilVersion is defined as const -1.
-
-#### What is the difference between uint(version) and int(targetVersion)?
-  version refers to an existing migration version coming from a source and therefor can never be negative. 
-  targetVersion can either be a version OR represent a NilVersion, which equals -1.    
-
-#### What's the difference between Next/Previous and Up/Down?
-  ```
-  1_first_migration.up           next ->  2_second_migration.up      ...
-  1_first_migration.down  <- previous     2_second_migration.down    ...
-  ```
- 
-#### Why two separate files (up and down) for a migration?
-  It makes all of our lives easier. No new markup/syntax to learn for users 
-  and existing database utility tools continue to work as expected.
-    
-#### How many migrations can migrate handle?
-  Whatever the maximum positive signed integer value is for your platform. 
-  For 32bit it would be 2,147,483,647 migrations. Migrate only keeps references to 
-  the currently run and pre-fetched migrations in memory. Please note that some 
-  source drivers need to do build a full "directory" tree first, which puts some
-  heat on the memory consumption. 
-    
-#### Are the table tests in migrate_test.go bloated?
-  Yes and no. There are duplicate test cases for sure but they don't hurt here. In fact
-  the tests are very visual now and might help new users understand expected behaviors quickly.
-  Migrate from version x to y and y is the last migration? Just check out the test for 
-  that particular case and know what's going on instantly.
-    
-#### What is Docker being used for?
-  Only for testing. See [testing/docker.go](testing/docker.go)
-    
-#### Why not just use docker-compose?
-  It doesn't give us enough runtime control for testing. We want to be able to bring up containers fast
-  and whenever we want, not just once at the beginning of all tests.
-    
-#### Can I maintain my driver in my own repository?
-  Yes, technically thats possible. We want to encourage you to contribute your driver to this respository though.
-  The driver's functionality is dictated by migrate's interfaces. That means there should really
-  just be one driver for a database/ source. We want to prevent a future where several drivers doing the exact same thing,
-  just implemented a bit differently, co-exist somewhere on Github. If users have to do research first to find the
-  "best" available driver for a database in order to get started, we would have failed as an open source community.
-
-#### Can I mix multiple sources during a batch of migrations?
-  No.
-
-#### What does "dirty" database mean?
-  Before a migration runs, each database sets a dirty flag. Execution stops if a migration fails and the dirty state persists,
-  which prevents attempts to run more migrations on top of a failed migration. You need to manually fix the error
-  and then "force" the expected version.
-
-  
+# FAQ
+
+#### How is the code base structured?
+  ```
+  /          package migrate (the heart of everything)
+  /cli       the CLI wrapper
+  /database  database driver and sub directories have the actual driver implementations
+  /source    source driver and sub directories have the actual driver implementations
+  ```
+
+#### Why is there no `source/driver.go:Last()`?
+  It's not needed. And unless the source has a "native" way to read a directory in reversed order,
+  it might be expensive to do a full directory scan in order to get the last element.
+
+#### What is a NilMigration? NilVersion?
+  NilMigration defines a migration without a body. NilVersion is defined as const -1.
+
+#### What is the difference between uint(version) and int(targetVersion)?
+  version refers to an existing migration version coming from a source and therefor can never be negative.
+  targetVersion can either be a version OR represent a NilVersion, which equals -1.
+
+#### What's the difference between Next/Previous and Up/Down?
+  ```
+  1_first_migration.up.extension           next ->  2_second_migration.up.extension      ...
+  1_first_migration.down.extension  <- previous     2_second_migration.down.extension    ...
+  ```
+
+#### Why two separate files (up and down) for a migration?
+  It makes all of our lives easier. No new markup/syntax to learn for users
+  and existing database utility tools continue to work as expected.
+
+#### How many migrations can migrate handle?
+  Whatever the maximum positive signed integer value is for your platform.
+  For 32bit it would be 2,147,483,647 migrations. Migrate only keeps references to
+  the currently run and pre-fetched migrations in memory. Please note that some
+  source drivers need to do build a full "directory" tree first, which puts some
+  heat on the memory consumption.
+
+#### Are the table tests in migrate_test.go bloated?
+  Yes and no. There are duplicate test cases for sure but they don't hurt here. In fact
+  the tests are very visual now and might help new users understand expected behaviors quickly.
+  Migrate from version x to y and y is the last migration? Just check out the test for
+  that particular case and know what's going on instantly.
+
+#### What is Docker being used for?
+  Only for testing. See [testing/docker.go](testing/docker.go)
+
+#### Why not just use docker-compose?
+  It doesn't give us enough runtime control for testing. We want to be able to bring up containers fast
+  and whenever we want, not just once at the beginning of all tests.
+
+#### Can I maintain my driver in my own repository?
+  Yes, technically thats possible. We want to encourage you to contribute your driver to this respository though.
+  The driver's functionality is dictated by migrate's interfaces. That means there should really
+  just be one driver for a database/ source. We want to prevent a future where several drivers doing the exact same thing,
+  just implemented a bit differently, co-exist somewhere on Github. If users have to do research first to find the
+  "best" available driver for a database in order to get started, we would have failed as an open source community.
+
+#### Can I mix multiple sources during a batch of migrations?
+  No.
+
+#### What does "dirty" database mean?
+  Before a migration runs, each database sets a dirty flag. Execution stops if a migration fails and the dirty state persists,
+  which prevents attempts to run more migrations on top of a failed migration. You need to manually fix the error
+  and then "force" the expected version.
+
+

Gopkg.lock

@@ -0,0 +1,659 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:098b27970336695d686ef8a701328cfb231445e2d54564d09c3b0c7d43ce129a"
+  name = "cloud.google.com/go"
+  packages = [
+    "civil",
+    "compute/metadata",
+    "iam",
+    "internal",
+    "internal/atomiccache",
+    "internal/fields",
+    "internal/optional",
+    "internal/protostruct",
+    "internal/trace",
+    "internal/version",
+    "longrunning",
+    "longrunning/autogen",
+    "spanner",
+    "spanner/admin/database/apiv1",
+    "storage",
+  ]
+  pruneopts = "UT"
+  revision = "0fd7230b2a7505833d5f69b75cbd6c9582401479"
+  version = "v0.23.0"
+
+[[projects]]
+  digest = "1:adbfc2db750d6fbe0c165ad801ba2d730883a3bc40bc8fe829516eb42ed17771"
+  name = "github.com/Microsoft/go-winio"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "a6d595ae73cf27a1b8fc32930668708f45ce1c85"
+  version = "v0.4.9"
+
+[[projects]]
+  digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc"
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
+  version = "v1.0.6"
+
+[[projects]]
+  digest = "1:1a42d6d0e8fe8cc1024ed542c5f8a0bc7346a292701b3bd94a07996f29fcbd38"
+  name = "github.com/aws/aws-sdk-go"
+  packages = [
+    "aws",
+    "aws/awserr",
+    "aws/awsutil",
+    "aws/client",
+    "aws/client/metadata",
+    "aws/corehandlers",
+    "aws/credentials",
+    "aws/credentials/ec2rolecreds",
+    "aws/credentials/endpointcreds",
+    "aws/credentials/stscreds",
+    "aws/csm",
+    "aws/defaults",
+    "aws/ec2metadata",
+    "aws/endpoints",
+    "aws/request",
+    "aws/session",
+    "aws/signer/v4",
+    "internal/sdkio",
+    "internal/sdkrand",
+    "internal/sdkuri",
+    "internal/shareddefaults",
+    "private/protocol",
+    "private/protocol/eventstream",
+    "private/protocol/eventstream/eventstreamapi",
+    "private/protocol/query",
+    "private/protocol/query/queryutil",
+    "private/protocol/rest",
+    "private/protocol/restxml",
+    "private/protocol/xml/xmlutil",
+    "service/s3",
+    "service/s3/s3iface",
+    "service/sts",
+  ]
+  pruneopts = "UT"
+  revision = "468b9714c11f10b22e533253b35eb9c28f4be691"
+  version = "v1.14.32"
+
+[[projects]]
+  branch = "master"
+  digest = "1:568184e644ca0114e16fa472037e18bb23a8c0668f9da12f3d2b059e0c548637"
+  name = "github.com/cockroachdb/cockroach-go"
+  packages = ["crdb"]
+  pruneopts = "UT"
+  revision = "59c0560478b705bf9bd12f9252224a0fad7c87df"
+
+[[projects]]
+  branch = "master"
+  digest = "1:3ba3d94d45f2d5c4b3411452474d96996b7e0dce730b689920f7c307511e5655"
+  name = "github.com/cznic/b"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "35e9bbe41f07452a183c517a5fc5f3c9f45eaa0f"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4688e1d4b22367c5bd24fe65f44b3e53a443a93fd19cf34169f1c8337d93dcf7"
+  name = "github.com/cznic/fileutil"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "6a051e75936f623600b67c2b1116b6b6c0ffb936"
+
+[[projects]]
+  digest = "1:a9e2943ed681d4758a43d1bd9e80d7e993b66ce5adc7aa5dcc083ba48a47a4eb"
+  name = "github.com/cznic/internal"
+  packages = [
+    "buffer",
+    "file",
+    "slice",
+  ]
+  pruneopts = "UT"
+  revision = "cef02a853c3a93623c42eacd574e7ea05f55531b"
+  version = "1.0.0"
+
+[[projects]]
+  digest = "1:ec7b58207ac8eee1c554b7947b3f5124f711238a80edb7224a53bae7263c95ae"
+  name = "github.com/cznic/lldb"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "bea8611dd5c407f3c5eab9f9c68e887a27dc6f0e"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:42951d361293c2f7068ab0411afeb57856afba843fe681cea1e2731b47021222"
+  name = "github.com/cznic/mathutil"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ca4c9f2c136954238c3158b92de72078c7672ecc"
+
+[[projects]]
+  digest = "1:905947603b7f1066a7149576b2cbad2e6f890729f892c827cdbcee046d07db9c"
+  name = "github.com/cznic/ql"
+  packages = [
+    ".",
+    "driver",
+    "vendored/github.com/camlistore/go4/lock",
+  ]
+  pruneopts = "UT"
+  revision = "7a63cd7aa46ecd9f549b96983029576af2178f60"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:06877d57543857a87186f43b6195bbdf5e8f4a0f51412fdf4baef504cead7973"
+  name = "github.com/cznic/sortutil"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "4c7342852e65c2088c981288f2c5610d10b9f7f4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8a26e11e94f1c9f03ab9fc1e816b003629d41b26ab41eefcb7444fad5b24fc4b"
+  name = "github.com/cznic/strutil"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "529a34b1c186b483642a7a230c67521d9aa4b0fb"
+
+[[projects]]
+  branch = "master"
+  digest = "1:bb8236408f88f411f565dffcf1e648fe34c7456820b707f96ccbfb89e1cd8eeb"
+  name = "github.com/cznic/zappy"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2533cb5b45cc6c07421468ce262899ddc9d53fb7"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4189ee6a3844f555124d9d2656fe7af02fca961c2a9bad9074789df13a0c62e0"
+  name = "github.com/docker/distribution"
+  packages = [
+    "digestset",
+    "reference",
+  ]
+  pruneopts = "UT"
+  revision = "0dae0957e5fe3156c265d22bef4cba9efbf388e2"
+
+[[projects]]
+  digest = "1:ec821dda59d7dd340498d74f798aa218b2c782bba54a690e866dc4f520d900d5"
+  name = "github.com/docker/docker"
+  packages = [
+    "api",
+    "api/types",
+    "api/types/blkiodev",
+    "api/types/container",
+    "api/types/events",
+    "api/types/filters",
+    "api/types/image",
+    "api/types/mount",
+    "api/types/network",
+    "api/types/registry",
+    "api/types/strslice",
+    "api/types/swarm",
+    "api/types/time",
+    "api/types/versions",
+    "api/types/volume",
+    "client",
+    "pkg/ioutils",
+    "pkg/longpath",
+    "pkg/system",
+    "pkg/tlsconfig",
+  ]
+  pruneopts = "UT"
+  revision = "90d35abf7b3535c1c319c872900fbd76374e521c"
+  version = "v17.05.0-ce-rc3"
+
+[[projects]]
+  digest = "1:b6b5c3e8da0fb8073cd2886ba249a40f4402b4391ca6eba905a142cceea97a12"
+  name = "github.com/docker/go-connections"
+  packages = [
+    "nat",
+    "sockets",
+    "tlsconfig",
+  ]
+  pruneopts = "UT"
+  revision = "3ede32e2033de7505e6500d6c868c2b9ed9f169d"
+  version = "v0.3.0"
+
+[[projects]]
+  digest = "1:6f82cacd0af5921e99bf3f46748705239b36489464f4529a1589bc895764fb18"
+  name = "github.com/docker/go-units"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "47565b4f722fb6ceae66b95f853feed578a4a51c"
+  version = "v0.3.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4841e14252a2cecf11840bd05230412ad469709bbacfc12467e2ce5ad07f339b"
+  name = "github.com/docker/libtrust"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "aabc10ec26b754e797f9028f4589c5b7bd90dc20"
+
+[[projects]]
+  branch = "master"
+  digest = "1:67d0b50be0549e610017cb91e0b0b745ec0cad7c613bc8e18ff2d1c1fc8825a7"
+  name = "github.com/edsrzf/mmap-go"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0bce6a6887123b67a60366d2c9fe2dfb74289d2e"
+
+[[projects]]
+  digest = "1:3a1c71661e5d956a3c3ff639dba511871757b5f37cb2107abf717d631ece8b1a"
+  name = "github.com/fsouza/fake-gcs-server"
+  packages = ["fakestorage"]
+  pruneopts = "UT"
+  revision = "9162fe06459e3d9859987fc2802fa729ddb6dc53"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:fe8a03a8222d5b913f256972933d26d24ad7c8286692a42943bc01633cc8fce3"
+  name = "github.com/go-ini/ini"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "358ee7663966325963d4e8b2e1fbd570c5195153"
+  version = "v1.38.1"
+
+[[projects]]
+  digest = "1:adea5a94903eb4384abef30f3d878dc9ff6b6b5b0722da25b82e5169216dfb61"
+  name = "github.com/go-sql-driver/mysql"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "d523deb1b23d913de5bdada721a6071e71283618"
+  version = "v1.4.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:2b43ef0cd185eb036ccd68b629c33aeb10d4ee3264a3912ca25ef1a5ade9c439"
+  name = "github.com/gocql/gocql"
+  packages = [
+    ".",
+    "internal/lru",
+    "internal/murmur",
+    "internal/streams",
+  ]
+  pruneopts = "UT"
+  revision = "e06f8c1bcd787e6bf0608288b314522f08cc7848"
+
+[[projects]]
+  digest = "1:d6d8ef66dbf92848883e228323ca4ee7404eb4fe3681c0e0395f515f128e0d29"
+  name = "github.com/golang/protobuf"
+  packages = [
+    "proto",
+    "protoc-gen-go/descriptor",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/empty",
+    "ptypes/struct",
+    "ptypes/timestamp",
+  ]
+  pruneopts = "UT"
+  revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4a0c6bb4805508a6287675fac876be2ac1182539ca8a32468d8128882e9d5009"
+  name = "github.com/golang/snappy"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a"
+
+[[projects]]
+  digest = "1:51bee9f1987dcdb9f9a1b4c20745d78f6bf6f5f14ad4e64ca883eb64df4c0045"
+  name = "github.com/google/go-github"
+  packages = ["github"]
+  pruneopts = "UT"
+  revision = "e48060a28fac52d0f1cb758bc8b87c07bac4a87d"
+  version = "v15.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:a63cff6b5d8b95638bfe300385d93b2a6d9d687734b863da8e09dc834510a690"
+  name = "github.com/google/go-querystring"
+  packages = ["query"]
+  pruneopts = "UT"
+  revision = "53e6ce116135b80d037921a7fdd5138cf32d7a8a"
+
+[[projects]]
+  digest = "1:e145e9710a10bc114a6d3e2738aadf8de146adaa031854ffdf7bbfe15da85e63"
+  name = "github.com/googleapis/gax-go"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "317e0006254c44a0ac427cc52a0e083ff0b9622f"
+  version = "v2.0.0"
+
+[[projects]]
+  digest = "1:c79fb010be38a59d657c48c6ba1d003a8aa651fa56b579d959d74573b7dff8e1"
+  name = "github.com/gorilla/context"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "08b5f424b9271eedf6f9f0ce86cb9396ed337a42"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:e73f5b0152105f18bc131fba127d9949305c8693f8a762588a82a48f61756f5f"
+  name = "github.com/gorilla/mux"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e3702bed27f0d39777b0b37b664b6280e8ef8fbf"
+  version = "v1.6.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:364b908b9b27b97ab838f2f6f1b1f46281fa29b978a037d72a9b1d4f6d940190"
+  name = "github.com/hailocab/go-hostpool"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e80d13ce29ede4452c43dea11e79b9bc8a15b478"
+
+[[projects]]
+  digest = "1:e22af8c7518e1eab6f2eab2b7d7558927f816262586cd6ed9f349c97a6c285c4"
+  name = "github.com/jmespath/go-jmespath"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0b12d6b5"
+
+[[projects]]
+  digest = "1:729cb96e4ff32f992aab19a58384fc4304c05f414a9169ef46b8c6ebb5515f77"
+  name = "github.com/kshvakov/clickhouse"
+  packages = [
+    ".",
+    "lib/binary",
+    "lib/column",
+    "lib/data",
+    "lib/protocol",
+    "lib/types",
+    "lib/writebuffer",
+  ]
+  pruneopts = "UT"
+  revision = "8a2dd1e831a6c7381c11d40bcaf80ae98023c605"
+  version = "v1.3.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:37ce7d7d80531b227023331002c0d42b4b4b291a96798c82a049d03a54ba79e4"
+  name = "github.com/lib/pq"
+  packages = [
+    ".",
+    "oid",
+  ]
+  pruneopts = "UT"
+  revision = "90697d60dd844d5ef6ff15135d0203f65d2f53b8"
+
+[[projects]]
+  digest = "1:3cafc6a5a1b8269605d9df4c6956d43d8011fc57f266ca6b9d04da6c09dee548"
+  name = "github.com/mattn/go-sqlite3"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "25ecb14adfc7543176f7d85291ec7dba82c6f7e4"
+  version = "v1.9.0"
+
+[[projects]]
+  digest = "1:ee4d4af67d93cc7644157882329023ce9a7bcfce956a079069a9405521c7cc8d"
+  name = "github.com/opencontainers/go-digest"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "279bed98673dd5bef374d3b6e4b09e2af76183bf"
+  version = "v1.0.0-rc1"
+
+[[projects]]
+  digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747"
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
+  version = "v0.8.0"
+
+[[projects]]
+  digest = "1:4ed20c76a0526d584d895c0a21c518c1d5a84ff97bd3c5828f3682016445ed39"
+  name = "go.opencensus.io"
+  packages = [
+    ".",
+    "exporter/stackdriver/propagation",
+    "internal",
+    "internal/tagencoding",
+    "plugin/ocgrpc",
+    "plugin/ochttp",
+    "plugin/ochttp/propagation/b3",
+    "stats",
+    "stats/internal",
+    "stats/view",
+    "tag",
+    "trace",
+    "trace/internal",
+    "trace/propagation",
+  ]
+  pruneopts = "UT"
+  revision = "e262766cd0d230a1bb7c37281e345e465f19b41b"
+  version = "v0.14.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8"
+  name = "golang.org/x/crypto"
+  packages = ["ssh/terminal"]
+  pruneopts = "UT"
+  revision = "c126467f60eb25f8f27e5a981f32a87e3965053f"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4d337ebc84e0ed0205f84f919934e70d830df9c86fc429ca8ce7ac286e29d247"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/socks",
+    "internal/timeseries",
+    "proxy",
+    "trace",
+  ]
+  pruneopts = "UT"
+  revision = "3673e40ba22529d22c3fd7c93e97b0ce50fa7bdd"
+
+[[projects]]
+  branch = "master"
+  digest = "1:bea0314c10bd362ab623af4880d853b5bad3b63d0ab9945c47e461b8d04203ed"
+  name = "golang.org/x/oauth2"
+  packages = [
+    ".",
+    "google",
+    "internal",
+    "jws",
+    "jwt",
+  ]
+  pruneopts = "UT"
+  revision = "3d292e4d0cdc3a0113e6d207bb137145ef1de42f"
+
+[[projects]]
+  branch = "master"
+  digest = "1:be95d758fc4d9216e5d41ff5b98b46938fba85ca5bc2ddc45a1b03e2bb10fe7c"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "UT"
+  revision = "e072cadbbdc8dd3d3ffa82b8b4b9304c261d9311"
+
+[[projects]]
+  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+  ]
+  pruneopts = "UT"
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7db86209b441978ca91b574ec2ec5a12a6c39bc89b659ca667d99eb96521d587"
+  name = "golang.org/x/tools"
+  packages = [
+    "godoc/vfs",
+    "godoc/vfs/mapfs",
+  ]
+  pruneopts = "UT"
+  revision = "526516e9c4bf5a3f76fe506dec01ca51d04cbe50"
+
+[[projects]]
+  branch = "master"
+  digest = "1:2892dda36e78635b8ef9e64be5af673150ff9a6c5e3946e9102353e9f01d8b81"
+  name = "google.golang.org/api"
+  packages = [
+    "gensupport",
+    "googleapi",
+    "googleapi/internal/uritemplates",
+    "googleapi/transport",
+    "internal",
+    "iterator",
+    "option",
+    "storage/v1",
+    "transport",
+    "transport/grpc",
+    "transport/http",
+  ]
+  pruneopts = "UT"
+  revision = "2c45710c7f3fb0ab63506810a1ba84325ab90ab8"
+
+[[projects]]
+  digest = "1:0e781d9592d20f30c4280da30f27b448b4815215f9b43b5258b763a79fb98e98"
+  name = "google.golang.org/appengine"
+  packages = [
+    ".",
+    "cloudsql",
+    "internal",
+    "internal/app_identity",
+    "internal/base",
+    "internal/datastore",
+    "internal/log",
+    "internal/modules",
+    "internal/remote_api",
+    "internal/socket",
+    "internal/urlfetch",
+    "socket",
+    "urlfetch",
+  ]
+  pruneopts = "UT"
+  revision = "b1f26356af11148e710935ed1ac8a7f5702c7612"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7381a470b84bba1d4ded5a158604b04bd002dbb265a63f416a9329bfeee095c7"
+  name = "google.golang.org/genproto"
+  packages = [
+    "googleapis/api/annotations",
+    "googleapis/iam/v1",
+    "googleapis/longrunning",
+    "googleapis/rpc/code",
+    "googleapis/rpc/errdetails",
+    "googleapis/rpc/status",
+    "googleapis/spanner/admin/database/v1",
+    "googleapis/spanner/v1",
+  ]
+  pruneopts = "UT"
+  revision = "02b4e95473316948020af0b7a4f0f22c73929b0e"
+
+[[projects]]
+  digest = "1:686525281321f81747cfb0bba0bc384511bbdc5cdc92a6aa1afe5f1808f82c36"
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "codes",
+    "connectivity",
+    "credentials",
+    "credentials/oauth",
+    "encoding",
+    "encoding/proto",
+    "grpclog",
+    "internal",
+    "internal/backoff",
+    "internal/channelz",
+    "internal/grpcrand",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "stats",
+    "status",
+    "tap",
+    "transport",
+  ]
+  pruneopts = "UT"
+  revision = "168a6198bcb0ef175f7dacec0b8691fc141dc9b8"
+  version = "v1.13.0"
+
+[[projects]]
+  digest = "1:2d1fbdc6777e5408cabeb02bf336305e724b925ff4546ded0fa8715a7267922a"
+  name = "gopkg.in/inf.v0"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "d2d2541c53f18d2a059457998ce2876cc8e67cbf"
+  version = "v0.9.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "cloud.google.com/go/spanner",
+    "cloud.google.com/go/spanner/admin/database/apiv1",
+    "cloud.google.com/go/storage",
+    "github.com/aws/aws-sdk-go/aws",
+    "github.com/aws/aws-sdk-go/aws/session",
+    "github.com/aws/aws-sdk-go/service/s3",
+    "github.com/aws/aws-sdk-go/service/s3/s3iface",
+    "github.com/cockroachdb/cockroach-go/crdb",
+    "github.com/cznic/ql/driver",
+    "github.com/docker/docker/api/types",
+    "github.com/docker/docker/api/types/container",
+    "github.com/docker/docker/api/types/network",
+    "github.com/docker/docker/client",
+    "github.com/fsouza/fake-gcs-server/fakestorage",
+    "github.com/go-sql-driver/mysql",
+    "github.com/gocql/gocql",
+    "github.com/google/go-github/github",
+    "github.com/kshvakov/clickhouse",
+    "github.com/lib/pq",
+    "github.com/mattn/go-sqlite3",
+    "golang.org/x/net/context",
+    "golang.org/x/tools/godoc/vfs",
+    "golang.org/x/tools/godoc/vfs/mapfs",
+    "google.golang.org/api/iterator",
+    "google.golang.org/genproto/googleapis/spanner/admin/database/v1",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,98 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/aws/aws-sdk-go"
+  version = "1.13.47"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/cockroachdb/cockroach-go"
+
+[[constraint]]
+  name = "github.com/cznic/ql"
+  version = "1.1.0"
+
+[[constraint]]
+  name = "github.com/docker/docker"
+  version = "v17.05.0-ce"
+
+[[constraint]]
+  name = "github.com/fsouza/fake-gcs-server"
+  version = "1.0.0"
+
+[[constraint]]
+  name = "github.com/go-sql-driver/mysql"
+  version = "v1.4.0"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/gocql/gocql"
+
+[[constraint]]
+  name = "github.com/google/go-github"
+  version = "15.0.0"
+
+[[constraint]]
+  name = "github.com/kshvakov/clickhouse"
+  version = "1.3.3"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/lib/pq"
+
+[[constraint]]
+  name = "github.com/mattn/go-sqlite3"
+  version = "1.6.0"
+
+[[constraint]]
+  branch = "master"
+  name = "golang.org/x/net"
+
+[[constraint]]
+  branch = "master"
+  name = "google.golang.org/api"
+
+[[constraint]]
+  branch = "master"
+  name = "google.golang.org/genproto"
+
+[[override]]
+  name = "cloud.google.com/go"
+  version = "0.23.0"
+
+[[override]]
+  branch = "master"
+  name = "golang.org/x/tools"
+
+[[override]]
+  branch = "master"
+  name = "github.com/docker/distribution"
+
+[prune]
+  go-tests = true
+  unused-packages = true

MIGRATIONS.md

@@ -1,5 +1,81 @@
-# Migrations
-
-## Best practices: How to write migrations.
-
-@TODO
+# Migrations
+
+## Migration Filename Format
+
+A single logical migration is represented as two separate migration files, one
+to migrate "up" to the specified version from the previous version, and a second
+to migrate back "down" to the previous version.  These migrations can be provided
+by any one of the supported [migration sources](./README.md#migration-sources).
+
+The ordering and direction of the migration files is determined by the filenames
+used for them.  `migrate` expects the filenames of migrations to have the format:
+
+    {version}_{title}.up.{extension}
+    {version}_{title}.down.{extension}
+
+The `title` of each migration is unused, and is only for readability.  Similarly,
+the `extension` of the migration files is not checked by the library, and should
+be an appropriate format for the database in use (`.sql` for SQL variants, for
+instance).
+
+Versions of migrations may be represented as any 64 bit unsigned integer.
+All migrations are applied upward in order of increasing version number, and
+downward by decreasing version number.
+
+Common versioning schemes include incrementing integers:
+
+    1_initialize_schema.down.sql
+    1_initialize_schema.up.sql
+    2_add_table.down.sql
+    2_add_table.up.sql
+    ...
+
+Or timestamps at an appropriate resolution:
+
+    1500360784_initialize_schema.down.sql
+    1500360784_initialize_schema.up.sql
+    1500445949_add_table.down.sql
+    1500445949_add_table.up.sql
+    ...
+
+But any scheme resulting in distinct, incrementing integers as versions is valid.
+
+It is suggested that the version number of corresponding `up` and `down` migration
+files be equivalent for clarity, but they are allowed to differ so long as the
+relative ordering of the migrations is preserved.
+
+The migration files are permitted to be empty, so in the event that a migration
+is a no-op or is irreversible, it is recommended to still include both migration
+files, and either leaving them empty or adding a comment as appropriate.
+
+## Migration Content Format
+
+The format of the migration files themselves varies between database systems.
+Different databases have different semantics around schema changes and when and
+how they are allowed to occur
+(for instance, [if schema changes can occur within a transaction](https://wiki.postgresql.org/wiki/Transactional_DDL_in_PostgreSQL:_A_Competitive_Analysis)).
+
+As such, the `migrate` library has little to no checking around the format of
+migration sources.  The migration files are generally processed directly by the
+drivers as raw operations.
+
+## Reversibility of Migrations
+
+Best practice for writing schema migration is that all migrations should be
+reversible.  It should in theory be possible for run migrations down and back up
+through any and all versions with the state being fully cleaned and recreated
+by doing so.
+
+By adhering to this recommended practice, development and deployment of new code
+is cleaner and easier (cleaning database state for a new feature should be as
+easy as migrating down to a prior version, and back up to the latest).
+
+As opposed to some other migration libraries, `migrate` represents up and down
+migrations as separate files.  This prevents any non-standard file syntax from
+being introduced which may result in unintended behavior or errors, depending
+on what database is processing the file.
+
+While it is technically possible for an up or down migration to exist on its own
+without an equivalently versioned counterpart, it is strongly recommended to
+always include a down migration which cleans up the state of the corresponding
+up migration.

Makefile

@@ -1,15 +1,16 @@
-SOURCE ?= file go-bindata github aws-s3 google-cloud-storage
-DATABASE ?= postgres mysql redshift
+SOURCE ?= file go_bindata github aws_s3 google_cloud_storage godoc_vfs
+DATABASE ?= postgres mysql redshift cassandra spanner cockroachdb clickhouse
 VERSION ?= $(shell git describe --tags 2>/dev/null | cut -c 2-)
 TEST_FLAGS ?=
 REPO_OWNER ?= $(shell cd .. && basename "$$(pwd)")
+COVERAGE_DIR ?= .coverage
 
 
 build-cli: clean
 	-mkdir ./cli/build
-	cd ./cli && GOOS=linux GOARCH=amd64 go build -a -o build/migrate.linux-amd64 -ldflags='-X main.Version=$(VERSION)' -tags '$(DATABASE) $(SOURCE)' . 
-	cd ./cli && GOOS=darwin GOARCH=amd64 go build -a -o build/migrate.darwin-amd64 -ldflags='-X main.Version=$(VERSION)' -tags '$(DATABASE) $(SOURCE)' . 
-	cd ./cli && GOOS=windows GOARCH=amd64 go build -a -o build/migrate.windows-amd64.exe -ldflags='-X main.Version=$(VERSION)' -tags '$(DATABASE) $(SOURCE)' . 
+	cd ./cli && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o build/migrate.linux-amd64 -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
+	cd ./cli && CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -a -o build/migrate.darwin-amd64 -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
+	cd ./cli && CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -a -o build/migrate.windows-amd64.exe -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
 	cd ./cli/build && find . -name 'migrate*' | xargs -I{} tar czf {}.tar.gz {}
 	cd ./cli/build && shasum -a 256 * > sha256sum.txt
 	cat ./cli/build/sha256sum.txt
@@ -24,11 +25,11 @@ test-short:
 
 
 test:
-	@-rm -r .coverage
-	@mkdir .coverage
-	make test-with-flags TEST_FLAGS='-v -race -covermode atomic -coverprofile .coverage/_$$(RAND).txt -bench=. -benchmem'
-	@echo 'mode: atomic' > .coverage/combined.txt
-	@cat .coverage/*.txt | grep -v 'mode: atomic' >> .coverage/combined.txt
+	@-rm -r $(COVERAGE_DIR)
+	@mkdir $(COVERAGE_DIR)
+	make test-with-flags TEST_FLAGS='-v -race -covermode atomic -coverprofile $$(COVERAGE_DIR)/_$$(RAND).txt -bench=. -benchmem -timeout 20m'
+	@echo 'mode: atomic' > $(COVERAGE_DIR)/combined.txt
+	@cat $(COVERAGE_DIR)/_*.txt | grep -v 'mode: atomic' >> $(COVERAGE_DIR)/combined.txt
 
 
 test-with-flags:
@@ -37,6 +38,7 @@ test-with-flags:
 
 	@go test $(TEST_FLAGS) .
 	@go test $(TEST_FLAGS) ./cli/...
+	@go test $(TEST_FLAGS) ./database
 	@go test $(TEST_FLAGS) ./testing/...
 
 	@echo -n '$(SOURCE)' | tr -s ' ' '\n' | xargs -I{} go test $(TEST_FLAGS) ./source/{}
@@ -53,14 +55,7 @@ kill-orphaned-docker-containers:
 
 
 html-coverage:
-	go tool cover -html=.coverage/combined.txt
-
-
-deps:
-	-go get -v -u ./... 
-	-go test -v -i ./...
-	# TODO: why is this not being fetched with the command above?
-	-go get -u github.com/fsouza/fake-gcs-server/fakestorage
+	go tool cover -html=$(COVERAGE_DIR)/combined.txt
 
 
 list-external-deps:
@@ -114,7 +109,7 @@ define external_deps
 endef
 
 
-.PHONY: build-cli clean test-short test test-with-flags deps html-coverage \
+.PHONY: build-cli clean test-short test test-with-flags html-coverage \
         restore-import-paths rewrite-import-paths list-external-deps release \
         docs kill-docs open-docs kill-orphaned-docker-containers
 

README.md

@@ -1,7 +1,11 @@
-[![Build Status](https://travis-ci.org/mattes/migrate.svg?branch=master)](https://travis-ci.org/mattes/migrate)
-[![GoDoc](https://godoc.org/github.com/mattes/migrate?status.svg)](https://godoc.org/github.com/mattes/migrate)
-[![Coverage Status](https://coveralls.io/repos/github/mattes/migrate/badge.svg?branch=v3.0-prev)](https://coveralls.io/github/mattes/migrate?branch=v3.0-prev)
-[![packagecloud.io](https://img.shields.io/badge/deb-packagecloud.io-844fec.svg)](https://packagecloud.io/mattes/migrate?filter=debs)
+[![Build Status](https://img.shields.io/travis/golang-migrate/migrate/master.svg)](https://travis-ci.org/golang-migrate/migrate)
+[![GoDoc](https://godoc.org/github.com/golang-migrate/migrate?status.svg)](https://godoc.org/github.com/golang-migrate/migrate)
+[![Coverage Status](https://img.shields.io/coveralls/github/golang-migrate/migrate/master.svg)](https://coveralls.io/github/golang-migrate/migrate?branch=master)
+[![packagecloud.io](https://img.shields.io/badge/deb-packagecloud.io-844fec.svg)](https://packagecloud.io/golang-migrate/migrate?filter=debs)
+[![Docker Pulls](https://img.shields.io/docker/pulls/migrate/migrate.svg)](https://hub.docker.com/r/migrate/migrate/)
+![Supported Go Versions](https://img.shields.io/badge/Go-1.10%2C%201.11-lightgrey.svg)
+[![GitHub Release](https://img.shields.io/github/release/golang-migrate/migrate.svg)](https://github.com/golang-migrate/migrate/releases)
+
 
 # migrate
 
@@ -9,12 +13,14 @@ __Database migrations written in Go. Use as [CLI](#cli-usage) or import as [libr
 
  * Migrate reads migrations from [sources](#migration-sources)
    and applies them in correct order to a [database](#databases).
- * Drivers are "dumb", migrate glues everything together and makes sure the logic is bulletproof.  
+ * Drivers are "dumb", migrate glues everything together and makes sure the logic is bulletproof.
    (Keeps the drivers lightweight, too.)
  * Database drivers don't assume things or try to correct user input. When in doubt, fail.
 
 
-Looking for [v1](https://github.com/mattes/migrate/tree/v1)?
+Looking for [v1](https://github.com/golang-migrate/migrate/tree/v1)?
+
+Forked from [mattes/migrate](https://github.com/mattes/migrate)
 
 
 ## Databases
@@ -24,26 +30,46 @@ Database drivers run migrations. [Add a new database?](database/driver.go)
   * [PostgreSQL](database/postgres)
   * [Redshift](database/redshift)
   * [Ql](database/ql)
-  * [Cassandra](database/cassandra) ([todo #164](https://github.com/mattes/migrate/issues/164))
-  * [SQLite](database/sqlite) ([todo #165](https://github.com/mattes/migrate/issues/165))
+  * [Cassandra](database/cassandra)
+  * [SQLite](database/sqlite3) ([todo #165](https://github.com/mattes/migrate/issues/165))
   * [MySQL/ MariaDB](database/mysql)
   * [Neo4j](database/neo4j) ([todo #167](https://github.com/mattes/migrate/issues/167))
   * [MongoDB](database/mongodb) ([todo #169](https://github.com/mattes/migrate/issues/169))
   * [CrateDB](database/crate) ([todo #170](https://github.com/mattes/migrate/issues/170))
   * [Shell](database/shell) ([todo #171](https://github.com/mattes/migrate/issues/171))
-  * [Google Cloud Spanner](database/spanner) ([todo #172](https://github.com/mattes/migrate/issues/172))
+  * [Google Cloud Spanner](database/spanner)
+  * [CockroachDB](database/cockroachdb)
+  * [ClickHouse](database/clickhouse)
 
+### Database URLs
 
+Database connection strings are specified via URLs. The URL format is driver dependent but generally has the form: `dbdriver://username:password@host:port/dbname?option1=true&option2=false`
+
+Any [reserved URL characters](https://en.wikipedia.org/wiki/Percent-encoding#Percent-encoding_reserved_characters) need to be escaped. Note, the `%` character also [needs to be escaped](https://en.wikipedia.org/wiki/Percent-encoding#Percent-encoding_the_percent_character)
+
+Explicitly, the following characters need to be escaped:
+`!`, `#`, `$`, `%`, `&`, `'`, `(`, `)`, `*`, `+`, `,`, `/`, `:`, `;`, `=`, `?`, `@`, `[`, `]`
+
+It's easiest to always run the URL parts of your DB connection URL (e.g. username, password, etc) through an URL encoder. See the example Python helpers below:
+```bash
+$ python3 -c 'import urllib.parse; print(urllib.parse.quote(input("String to encode: "), ""))'
+String to encode: FAKEpassword!#$%&'()*+,/:;=?@[]
+FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
+$ python2 -c 'import urllib; print urllib.quote(raw_input("String to encode: "), "")'
+String to encode: FAKEpassword!#$%&'()*+,/:;=?@[]
+FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
+$
+```
 
 ## Migration Sources
 
 Source drivers read migrations from local or remote sources. [Add a new source?](source/driver.go)
 
-  * [Filesystem](source/file) - read from fileystem (always included)
-  * [Go-Bindata](source/go-bindata) - read from embedded binary data ([jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata))
+  * [Filesystem](source/file) - read from fileystem
+  * [Go-Bindata](source/go_bindata) - read from embedded binary data ([jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata))
   * [Github](source/github) - read from remote Github repositories
-  * [AWS S3](source/aws-s3) - read from Amazon Web Services S3
-  * [Google Cloud Storage](source/google-cloud-storage) - read from Google Cloud Platform Storage
+  * [AWS S3](source/aws_s3) - read from Amazon Web Services S3
+  * [Google Cloud Storage](source/google_cloud_storage) - read from Google Cloud Platform Storage
 
 
 
@@ -55,32 +81,35 @@ Source drivers read migrations from local or remote sources. [Add a new source?]
 
 __[CLI Documentation](cli)__
 
-([brew todo #156](https://github.com/mattes/migrate/issues/156))
+### Basic usage:
 
 ```
-$ brew install migrate --with-postgres
-$ migrate -database postgres://localhost:5432/database up 2
+$ migrate -source file://path/to/migrations -database postgres://localhost:5432/database up 2
 ```
 
+### Docker usage
+
+```
+$ docker run -v {{ migration dir }}:/migrations --network host migrate/migrate 
+    -path=/migrations/ -database postgres://localhost:5432/database up 2
+```
 
 ## Use in your Go project
 
  * API is stable and frozen for this release (v3.x).
- * Package migrate has no external dependencies.
- * Only import the drivers you need.
-   (check [dependency_tree.txt](https://github.com/mattes/migrate/releases) for each driver)
+ * Uses [dep](https://github.com/golang/dep) to manage dependencies
  * To help prevent database corruptions, it supports graceful stops via `GracefulStop chan bool`.
  * Bring your own logger.
  * Uses `io.Reader` streams internally for low memory overhead.
  * Thread-safe and no goroutine leaks.
 
-__[Go Documentation](https://godoc.org/github.com/mattes/migrate)__
+__[Go Documentation](https://godoc.org/github.com/golang-migrate/migrate)__
 
 ```go
 import (
-    "github.com/mattes/migrate"
-    _ "github.com/mattes/migrate/database/postgres"
-    _ "github.com/mattes/migrate/source/github"
+    "github.com/golang-migrate/migrate"
+    _ "github.com/golang-migrate/migrate/database/postgres"
+    _ "github.com/golang-migrate/migrate/source/github"
 )
 
 func main() {
@@ -97,9 +126,9 @@ Want to use an existing database client?
 import (
     "database/sql"
     _ "github.com/lib/pq"
-    "github.com/mattes/migrate"
-    "github.com/mattes/migrate/database/postgres"
-    _ "github.com/mattes/migrate/source/file"
+    "github.com/golang-migrate/migrate"
+    "github.com/golang-migrate/migrate/database/postgres"
+    _ "github.com/golang-migrate/migrate/source/file"
 )
 
 func main() {
@@ -136,8 +165,4 @@ Also have a look at the [FAQ](FAQ.md).
 
 ---
 
-__Alternatives__
-
-https://bitbucket.org/liamstask/goose, https://github.com/tanel/dbmigrate,  
-https://github.com/BurntSushi/migration, https://github.com/DavidHuie/gomigrate,  
-https://github.com/rubenv/sql-migrate
+Looking for alternatives? [https://awesome-go.com/#database](https://awesome-go.com/#database).

cli/README.md

@@ -2,38 +2,46 @@
 
 ## Installation
 
-#### With Go toolchain
+#### Download pre-build binary (Windows, MacOS, or Linux)
+
+[Release Downloads](https://github.com/golang-migrate/migrate/releases)
 
 ```
-$ go get -u -d github.com/mattes/migrate/cli
-$ go build -tags 'postgres' -o /usr/local/bin/migrate github.com/mattes/migrate/cli
+$ curl -L https://github.com/golang-migrate/migrate/releases/download/$version/migrate.$platform-amd64.tar.gz | tar xvz
 ```
 
 #### MacOS
 
-([todo #156](https://github.com/mattes/migrate/issues/156))
+We have not released support for homebrew yet, but there is a live issue here: [todo #156](https://github.com/mattes/migrate/issues/156)
 
-```
-$ brew install migrate --with-postgres
-```
+Any help to make this happen would be appreciated!
 
 #### Linux (*.deb package)
 
 ```
-$ curl -L https://packagecloud.io/mattes/migrate/gpgkey | apt-key add -
-$ echo "deb https://packagecloud.io/mattes/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list
+$ curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey | apt-key add -
+$ echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list
 $ apt-get update
 $ apt-get install -y migrate
 ```
 
-#### Download pre-build binary (Windows, MacOS, or Linux)
-
-[Release Downloads](https://github.com/mattes/migrate/releases)
+#### With Go toolchain
 
 ```
-$ curl -L https://github.com/mattes/migrate/releases/download/$version/migrate.$platform-amd64.tar.gz | tar xvz
+$ go get -u -d github.com/golang-migrate/migrate/cli
+$ cd $GOPATH/src/github.com/golang-migrate/migrate/cli
+$ dep ensure
+$ go build -tags 'postgres' -o /usr/local/bin/migrate github.com/golang-migrate/migrate/cli
 ```
 
+##### Notes:
+1. This example builds the cli which will only work with postgres.  In order
+to build the cli for use with other databases, replace the `postgres` build tag
+with the appropriate database tag(s) for the databases desired.  The tags
+correspond to the names of the sub-packages underneath the
+[`database`](../database) package.
+1. Similarly to the database build tags, if you need to support other sources, use the appropriate build tag(s).
+1. Support for build constraints will be removed in the future: https://github.com/golang-migrate/migrate/issues/60
 
 
 ## Usage
@@ -45,7 +53,7 @@ Usage: migrate OPTIONS COMMAND [arg...]
 
 Options:
   -source          Location of the migrations (driver://url)
-  -path            Shorthand for -source=file://path 
+  -path            Shorthand for -source=file://path
   -database        Run migrations against this database (driver://url)
   -prefetch N      Number of migrations to load in advance before executing (default 10)
   -lock-timeout N  Allow N seconds to acquire database lock (default 15)
@@ -54,6 +62,10 @@ Options:
   -help            Print usage
 
 Commands:
+  create [-ext E] [-dir D] [-seq] [-digits N] [-format] NAME
+               Create a set of timestamped up/down migrations titled NAME, in directory D with extension E.
+               Use -seq option to generate sequential up/down migrations with N digits.
+               Use -format option to specify a Go time format string.
   goto V       Migrate to version V
   up [N]       Apply all or N up migrations
   down [N]     Apply all or N down migrations
@@ -66,7 +78,7 @@ Commands:
 So let's say you want to run the first two migrations
 
 ```
-$ migrate -database postgres://localhost:5432/database up 2
+$ migrate -source file://path/to/migrations -database postgres://localhost:5432/database up 2
 ```
 
 If your migrations are hosted on github

cli/build_aws-s3.go

@@ -1,7 +1,7 @@
-// +build aws-s3
+// +build aws_s3
 
 package main
 
 import (
-	_ "github.com/mattes/migrate/source/aws-s3"
+	_ "github.com/golang-migrate/migrate/source/aws_s3"
 )

cli/build_cassandra.go

@@ -0,0 +1,7 @@
+// +build cassandra
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/cassandra"
+)

cli/build_clickhouse.go

@@ -0,0 +1,8 @@
+// +build clickhouse
+
+package main
+
+import (
+	_ "github.com/kshvakov/clickhouse"
+	_ "github.com/golang-migrate/migrate/database/clickhouse"
+)

cli/build_cockroachdb.go

@@ -0,0 +1,7 @@
+// +build cockroachdb
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/cockroachdb"
+)

cli/build_github.go

@@ -3,5 +3,5 @@
 package main
 
 import (
-	_ "github.com/mattes/migrate/source/github"
+	_ "github.com/golang-migrate/migrate/source/github"
 )

cli/build_go-bindata.go

@@ -1,7 +1,7 @@
-// +build go-bindata
+// +build go_bindata
 
 package main
 
 import (
-	_ "github.com/mattes/migrate/source/go-bindata"
+	_ "github.com/golang-migrate/migrate/source/go_bindata"
 )

cli/build_godoc-vfs.go

@@ -0,0 +1,7 @@
+// +build godoc_vfs
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/godoc_vfs"
+)

cli/build_google-cloud-storage.go

@@ -1,7 +1,7 @@
-// +build google-cloud-storage
+// +build google_cloud_storage
 
 package main
 
 import (
-	_ "github.com/mattes/migrate/source/google-cloud-storage"
+	_ "github.com/golang-migrate/migrate/source/google_cloud_storage"
 )

cli/build_mysql.go

@@ -3,5 +3,5 @@
 package main
 
 import (
-	_ "github.com/mattes/migrate/database/mysql"
+	_ "github.com/golang-migrate/migrate/database/mysql"
 )

cli/build_postgres.go

@@ -3,5 +3,5 @@
 package main
 
 import (
-	_ "github.com/mattes/migrate/database/postgres"
+	_ "github.com/golang-migrate/migrate/database/postgres"
 )

cli/build_ql.go

@@ -3,5 +3,5 @@
 package main
 
 import (
-	_ "github.com/mattes/migrate/database/ql"
+	_ "github.com/golang-migrate/migrate/database/ql"
 )

cli/build_redshift.go

@@ -3,5 +3,5 @@
 package main
 
 import (
-	_ "github.com/mattes/migrate/database/redshift"
+	_ "github.com/golang-migrate/migrate/database/redshift"
 )

cli/build_spanner.go

@@ -0,0 +1,7 @@
+// +build spanner
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/spanner"
+)

cli/build_sqlite3.go

@@ -0,0 +1,7 @@
+// +build sqlite3
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/sqlite3"
+)

cli/commands.go

@@ -1,11 +1,96 @@
 package main
 
 import (
-	"github.com/mattes/migrate"
-	_ "github.com/mattes/migrate/database/stub" // TODO remove again
-	_ "github.com/mattes/migrate/source/file"
+	"errors"
+	"fmt"
+	"github.com/golang-migrate/migrate"
+	_ "github.com/golang-migrate/migrate/database/stub" // TODO remove again
+	_ "github.com/golang-migrate/migrate/source/file"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 )
 
+func nextSeq(matches []string, dir string, seqDigits int) (string, error) {
+	if seqDigits <= 0 {
+		return "", errors.New("Digits must be positive")
+	}
+
+	nextSeq := 1
+	if len(matches) > 0 {
+		filename := matches[len(matches)-1]
+		matchSeqStr := strings.TrimPrefix(filename, dir)
+		idx := strings.Index(matchSeqStr, "_")
+		if idx < 1 { // Using 1 instead of 0 since there should be at least 1 digit
+			return "", errors.New("Malformed migration filename: " + filename)
+		}
+		matchSeqStr = matchSeqStr[0:idx]
+		var err error
+		nextSeq, err = strconv.Atoi(matchSeqStr)
+		if err != nil {
+			return "", err
+		}
+		nextSeq++
+	}
+	if nextSeq <= 0 {
+		return "", errors.New("Next sequence number must be positive")
+	}
+
+	nextSeqStr := strconv.Itoa(nextSeq)
+	if len(nextSeqStr) > seqDigits {
+		return "", fmt.Errorf("Next sequence number %s too large. At most %d digits are allowed", nextSeqStr, seqDigits)
+	}
+	padding := seqDigits - len(nextSeqStr)
+	if padding > 0 {
+		nextSeqStr = strings.Repeat("0", padding) + nextSeqStr
+	}
+	return nextSeqStr, nil
+}
+
+func createCmd(dir string, startTime time.Time, format string, name string, ext string, seq bool, seqDigits int) {
+	var base string
+	if seq && format != defaultTimeFormat {
+		log.fatalErr(errors.New("The seq and format options are mutually exclusive"))
+	}
+	if seq {
+		if seqDigits <= 0 {
+			log.fatalErr(errors.New("Digits must be positive"))
+		}
+		matches, err := filepath.Glob(dir + "*" + ext)
+		if err != nil {
+			log.fatalErr(err)
+		}
+		nextSeqStr, err := nextSeq(matches, dir, seqDigits)
+		if err != nil {
+			log.fatalErr(err)
+		}
+		base = fmt.Sprintf("%v%v_%v.", dir, nextSeqStr, name)
+	} else {
+		switch format {
+		case "":
+			log.fatal("Time format may not be empty")
+		case "unix":
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.Unix(), name)
+		case "unixNano":
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.UnixNano(), name)
+		default:
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.Format(format), name)
+		}
+	}
+
+	os.MkdirAll(dir, os.ModePerm)
+	createFile(base + "up" + ext)
+	createFile(base + "down" + ext)
+}
+
+func createFile(fname string) {
+	if _, err := os.Create(fname); err != nil {
+		log.fatalErr(err)
+	}
+}
+
 func gotoCmd(m *migrate.Migrate, v uint) {
 	if err := m.Migrate(v); err != nil {
 		if err != migrate.ErrNoChange {

cli/commands_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestNextSeq(t *testing.T) {
+	cases := []struct {
+		name           string
+		matches        []string
+		dir            string
+		seqDigits      int
+		expected       string
+		expectedErrStr string
+	}{
+		{"Bad digits", []string{}, "migrationDir", 0, "", "Digits must be positive"},
+		{"Single digit initialize", []string{}, "migrationDir", 1, "1", ""},
+		{"Single digit malformed", []string{"bad"}, "migrationDir", 1, "", "Malformed migration filename: bad"},
+		{"Single digit no int", []string{"bad_bad"}, "migrationDir", 1, "", "strconv.Atoi: parsing \"bad\": invalid syntax"},
+		{"Single digit negative seq", []string{"-5_test"}, "migrationDir", 1, "", "Next sequence number must be positive"},
+		{"Single digit increment", []string{"3_test", "4_test"}, "migrationDir", 1, "5", ""},
+		{"Single digit overflow", []string{"9_test"}, "migrationDir", 1, "", "Next sequence number 10 too large. At most 1 digits are allowed"},
+		{"Zero-pad initialize", []string{}, "migrationDir", 6, "000001", ""},
+		{"Zero-pad malformed", []string{"bad"}, "migrationDir", 6, "", "Malformed migration filename: bad"},
+		{"Zero-pad no int", []string{"bad_bad"}, "migrationDir", 6, "", "strconv.Atoi: parsing \"bad\": invalid syntax"},
+		{"Zero-pad negative seq", []string{"-000005_test"}, "migrationDir", 6, "", "Next sequence number must be positive"},
+		{"Zero-pad increment", []string{"000003_test", "000004_test"}, "migrationDir", 6, "000005", ""},
+		{"Zero-pad overflow", []string{"999999_test"}, "migrationDir", 6, "", "Next sequence number 1000000 too large. At most 6 digits are allowed"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			nextSeq, err := nextSeq(c.matches, c.dir, c.seqDigits)
+			if nextSeq != c.expected {
+				t.Error("Incorrect nextSeq: " + nextSeq + " != " + c.expected)
+			}
+			if err != nil {
+				if err.Error() != c.expectedErrStr {
+					t.Error("Incorrect error: " + err.Error() + " != " + c.expectedErrStr)
+				}
+			} else if c.expectedErrStr != "" {
+				t.Error("Expected error: " + c.expectedErrStr + " but got nil instead")
+			}
+		})
+	}
+}

cli/examples/Dockerfile

@@ -3,8 +3,8 @@ FROM ubuntu:xenial
 RUN apt-get update && \
     apt-get install -y curl apt-transport-https
 
-RUN curl -L https://packagecloud.io/mattes/migrate/gpgkey | apt-key add - && \
-    echo "deb https://packagecloud.io/mattes/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list && \
+RUN curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey | apt-key add - && \
+    echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list && \
     apt-get update && \
     apt-get install -y migrate
 

cli/main.go

@@ -6,12 +6,17 @@ import (
 	"os"
 	"os/signal"
 	"strconv"
+	"strings"
 	"syscall"
 	"time"
 
-	"github.com/mattes/migrate"
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+	"github.com/golang-migrate/migrate/source"
 )
 
+const defaultTimeFormat = "20060102150405"
+
 // set main log
 var log = &Log{}
 
@@ -41,13 +46,19 @@ Options:
   -help            Print usage
 
 Commands:
+  create [-ext E] [-dir D] [-seq] [-digits N] [-format] NAME
+			   Create a set of timestamped up/down migrations titled NAME, in directory D with extension E.
+			   Use -seq option to generate sequential up/down migrations with N digits.
+			   Use -format option to specify a Go time format string.
   goto V       Migrate to version V
   up [N]       Apply all or N up migrations
   down [N]     Apply all or N down migrations
   drop         Drop everyting inside database
   force V      Set version V but don't run migration (ignores dirty state)
   version      Print current migration version
-`)
+
+Source drivers: `+strings.Join(source.List(), ", ")+`
+Database drivers: `+strings.Join(database.List(), ", ")+"\n")
 	}
 
 	flag.Parse()
@@ -101,6 +112,35 @@ Commands:
 	startTime := time.Now()
 
 	switch flag.Arg(0) {
+	case "create":
+		args := flag.Args()[1:]
+		seq := false
+		seqDigits := 6
+
+		createFlagSet := flag.NewFlagSet("create", flag.ExitOnError)
+		extPtr := createFlagSet.String("ext", "", "File extension")
+		dirPtr := createFlagSet.String("dir", "", "Directory to place file in (default: current working directory)")
+		formatPtr := createFlagSet.String("format", defaultTimeFormat, `The Go time format string to use. If the string "unix" or "unixNano" is specified, then the seconds or nanoseconds since January 1, 1970 UTC respectively will be used. Caution, due to the behavior of time.Time.Format(), invalid format strings will not error`)
+		createFlagSet.BoolVar(&seq, "seq", seq, "Use sequential numbers instead of timestamps (default: false)")
+		createFlagSet.IntVar(&seqDigits, "digits", seqDigits, "The number of digits to use in sequences (default: 6)")
+		createFlagSet.Parse(args)
+
+		if createFlagSet.NArg() == 0 {
+			log.fatal("error: please specify name")
+		}
+		name := createFlagSet.Arg(0)
+
+		if *extPtr == "" {
+			log.fatal("error: -ext flag must be specified")
+		}
+		*extPtr = "." + strings.TrimPrefix(*extPtr, ".")
+
+		if *dirPtr != "" {
+			*dirPtr = strings.Trim(*dirPtr, "/") + "/"
+		}
+
+		createCmd(*dirPtr, startTime, *formatPtr, name, *extPtr, seq, seqDigits)
+
 	case "goto":
 		if migraterErr != nil {
 			log.fatalErr(migraterErr)

database/cassandra/README.md

@@ -0,0 +1,35 @@
+# Cassandra
+
+* Drop command will not work on Cassandra 2.X because it rely on
+system_schema table which comes with 3.X
+* Other commands should work properly but are **not tested**
+* The Cassandra driver (gocql) does not natively support executing multipe statements in a single query. To allow for multiple statements in a single migration, you can use the `x-multi-statement` param. There are two important caveats:
+  * This mode splits the migration text into separately-executed statements by a semi-colon `;`. Thus `x-multi-statement` cannot be used when a statement in the migration contains a string with a semi-colon.
+  * The queries are not executed in any sort of transaction/batch, meaning you are responsible for fixing partial migrations.
+
+
+## Usage
+`cassandra://host:port/keyspace?param1=value&param2=value2`
+
+
+| URL Query  | Default value | Description |
+|------------|-------------|-----------|
+| `x-migrations-table` | schema_migrations | Name of the migrations table |
+| `x-multi-statement` | false | Enable multiple statements to be ran in a single migration (See note above) |
+| `port` | 9042 | The port to bind to  |
+| `consistency` | ALL | Migration consistency
+| `protocol` |  | Cassandra protocol version (3 or 4)
+| `timeout` | 1 minute | Migration timeout
+| `username` | nil | Username to use when authenticating. |
+| `password` | nil | Password to use when authenticating. |
+
+
+`timeout` is parsed using [time.ParseDuration(s string)](https://golang.org/pkg/time/#ParseDuration)
+
+
+## Upgrading from v1
+
+1. Write down the current migration version from schema_migrations
+2. `DROP TABLE schema_migrations`
+4. Download and install the latest migrate version.
+5. Force the current migration version with `migrate force <current_version>`.

database/cassandra/cassandra.go

@@ -0,0 +1,259 @@
+package cassandra
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gocql/gocql"
+	"github.com/golang-migrate/migrate/database"
+)
+
+func init() {
+	db := new(Cassandra)
+	database.Register("cassandra", db)
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var (
+	ErrNilConfig     = errors.New("no config")
+	ErrNoKeyspace    = errors.New("no keyspace provided")
+	ErrDatabaseDirty = errors.New("database is dirty")
+	ErrClosedSession = errors.New("session is closed")
+)
+
+type Config struct {
+	MigrationsTable string
+	KeyspaceName    string
+	MultiStatementEnabled bool
+}
+
+type Cassandra struct {
+	session  *gocql.Session
+	isLocked bool
+
+	// Open and WithInstance need to guarantee that config is never nil
+	config *Config
+}
+
+func WithInstance(session *gocql.Session, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	} else if len(config.KeyspaceName) == 0 {
+		return nil, ErrNoKeyspace
+	}
+
+	if session.Closed() {
+		return nil, ErrClosedSession
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	c := &Cassandra{
+		session: session,
+		config:  config,
+	}
+
+	if err := c.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (c *Cassandra) Open(url string) (database.Driver, error) {
+	u, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check for missing mandatory attributes
+	if len(u.Path) == 0 {
+		return nil, ErrNoKeyspace
+	}
+
+	cluster := gocql.NewCluster(u.Host)
+	cluster.Keyspace = strings.TrimPrefix(u.Path, "/")
+	cluster.Consistency = gocql.All
+	cluster.Timeout = 1 * time.Minute
+
+	if len(u.Query().Get("username")) > 0 && len(u.Query().Get("password")) > 0 {
+		authenticator := gocql.PasswordAuthenticator{
+			Username: u.Query().Get("username"),
+			Password: u.Query().Get("password"),
+		}
+		cluster.Authenticator = authenticator
+	}
+
+	// Retrieve query string configuration
+	if len(u.Query().Get("consistency")) > 0 {
+		var consistency gocql.Consistency
+		consistency, err = parseConsistency(u.Query().Get("consistency"))
+		if err != nil {
+			return nil, err
+		}
+
+		cluster.Consistency = consistency
+	}
+	if len(u.Query().Get("protocol")) > 0 {
+		var protoversion int
+		protoversion, err = strconv.Atoi(u.Query().Get("protocol"))
+		if err != nil {
+			return nil, err
+		}
+		cluster.ProtoVersion = protoversion
+	}
+	if len(u.Query().Get("timeout")) > 0 {
+		var timeout time.Duration
+		timeout, err = time.ParseDuration(u.Query().Get("timeout"))
+		if err != nil {
+			return nil, err
+		}
+		cluster.Timeout = timeout
+	}
+
+	session, err := cluster.CreateSession()
+	if err != nil {
+		return nil, err
+	}
+
+	return WithInstance(session, &Config{
+		KeyspaceName:    strings.TrimPrefix(u.Path, "/"),
+		MigrationsTable: u.Query().Get("x-migrations-table"),
+		MultiStatementEnabled: u.Query().Get("x-multi-statement") == "true",
+	})
+}
+
+func (c *Cassandra) Close() error {
+	c.session.Close()
+	return nil
+}
+
+func (c *Cassandra) Lock() error {
+	if c.isLocked {
+		return database.ErrLocked
+	}
+	c.isLocked = true
+	return nil
+}
+
+func (c *Cassandra) Unlock() error {
+	c.isLocked = false
+	return nil
+}
+
+func (c *Cassandra) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	// run migration
+	query := string(migr[:])
+
+	if c.config.MultiStatementEnabled {
+		// split query by semi-colon
+		queries := strings.Split(query, ";")
+
+		for _, q := range(queries) {
+			tq := strings.TrimSpace(q)
+			if (tq == "") { continue }
+			if err := c.session.Query(tq).Exec(); err != nil {
+				// TODO: cast to Cassandra error and get line number
+				return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+			}
+		}
+		return nil
+	}
+
+	if err := c.session.Query(query).Exec(); err != nil {
+		// TODO: cast to Cassandra error and get line number
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+	return nil
+}
+
+func (c *Cassandra) SetVersion(version int, dirty bool) error {
+	query := `TRUNCATE "` + c.config.MigrationsTable + `"`
+	if err := c.session.Query(query).Exec(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if version >= 0 {
+		query = `INSERT INTO "` + c.config.MigrationsTable + `" (version, dirty) VALUES (?, ?)`
+		if err := c.session.Query(query, version, dirty).Exec(); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	return nil
+}
+
+// Return current keyspace version
+func (c *Cassandra) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM "` + c.config.MigrationsTable + `" LIMIT 1`
+	err = c.session.Query(query).Scan(&version, &dirty)
+	switch {
+	case err == gocql.ErrNotFound:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if _, ok := err.(*gocql.Error); ok {
+			return database.NilVersion, false, nil
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (c *Cassandra) Drop() error {
+	// select all tables in current schema
+	query := fmt.Sprintf(`SELECT table_name from system_schema.tables WHERE keyspace_name='%s'`, c.config.KeyspaceName)
+	iter := c.session.Query(query).Iter()
+	var tableName string
+	for iter.Scan(&tableName) {
+		err := c.session.Query(fmt.Sprintf(`DROP TABLE %s`, tableName)).Exec()
+		if err != nil {
+			return err
+		}
+	}
+	// Re-create the version table
+	return c.ensureVersionTable()
+}
+
+// Ensure version table exists
+func (c *Cassandra) ensureVersionTable() error {
+	err := c.session.Query(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version bigint, dirty boolean, PRIMARY KEY(version))", c.config.MigrationsTable)).Exec()
+	if err != nil {
+		return err
+	}
+	if _, _, err = c.Version(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ParseConsistency wraps gocql.ParseConsistency
+// to return an error instead of a panicking.
+func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)
+			}
+		}
+	}()
+	consistency = gocql.ParseConsistency(consistencyStr)
+
+	return consistency, nil
+}

database/cassandra/cassandra_test.go

@@ -0,0 +1,56 @@
+package cassandra
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/gocql/gocql"
+
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
+)
+
+var versions = []mt.Version{
+	{Image: "cassandra:3.0.10"},
+	{Image: "cassandra:3.0"},
+}
+
+func isReady(i mt.Instance) bool {
+	// Cassandra exposes 5 ports (7000, 7001, 7199, 9042 & 9160)
+	// We only need the port bound to 9042, but we can only access to the first one
+	// through 'i.Port()' (which calls DockerContainer.firstPortMapping())
+	// So we need to get port mapping to retrieve correct port number bound to 9042
+	portMap := i.NetworkSettings().Ports
+	port, _ := strconv.Atoi(portMap["9042/tcp"][0].HostPort)
+
+	cluster := gocql.NewCluster(i.Host())
+	cluster.Port = port
+	cluster.Consistency = gocql.All
+	p, err := cluster.CreateSession()
+	if err != nil {
+		return false
+	}
+	defer p.Close()
+	// Create keyspace for tests
+	if err = p.Query("CREATE KEYSPACE testks WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor':1}").Exec(); err != nil {
+		return false
+	}
+	return true
+}
+
+func Test(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Cassandra{}
+			portMap := i.NetworkSettings().Ports
+			port, _ := strconv.Atoi(portMap["9042/tcp"][0].HostPort)
+			addr := fmt.Sprintf("cassandra://%v:%v/testks", i.Host(), port)
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			defer d.Close()
+			dt.Test(t, d, []byte("SELECT table_name from system_schema.tables"))
+		})
+}

database/clickhouse/README.md

@@ -0,0 +1,19 @@
+# ClickHouse
+
+`clickhouse://host:port?username=user&password=qwerty&database=clicks&x-multi-statement=true`
+
+| URL Query  | Description |
+|------------|-------------|
+| `x-migrations-table`| Name of the migrations table |
+| `database` | The name of the database to connect to |
+| `username` | The user to sign in as |
+| `password` | The user's password | 
+| `host` | The host to connect to. |
+| `port` | The port to bind to. |
+| `x-multi-statement` | false | Enable multiple statements to be ran in a single migration (See note below) |
+
+## Notes
+
+* The Clickhouse driver does not natively support executing multipe statements in a single query. To allow for multiple statements in a single migration, you can use the `x-multi-statement` param. There are two important caveats:
+  * This mode splits the migration text into separately-executed statements by a semi-colon `;`. Thus `x-multi-statement` cannot be used when a statement in the migration contains a string with a semi-colon.
+  * The queries are not executed in any sort of transaction/batch, meaning you are responsible for fixing partial migrations.

database/clickhouse/clickhouse.go

@@ -0,0 +1,215 @@
+package clickhouse
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+)
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var ErrNilConfig = fmt.Errorf("no config")
+
+type Config struct {
+	DatabaseName          string
+	MigrationsTable       string
+	MultiStatementEnabled bool
+}
+
+func init() {
+	database.Register("clickhouse", &ClickHouse{})
+}
+
+func WithInstance(conn *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := conn.Ping(); err != nil {
+		return nil, err
+	}
+
+	ch := &ClickHouse{
+		conn:   conn,
+		config: config,
+	}
+
+	if err := ch.init(); err != nil {
+		return nil, err
+	}
+
+	return ch, nil
+}
+
+type ClickHouse struct {
+	conn   *sql.DB
+	config *Config
+}
+
+func (ch *ClickHouse) Open(dsn string) (database.Driver, error) {
+	purl, err := url.Parse(dsn)
+	if err != nil {
+		return nil, err
+	}
+	q := migrate.FilterCustomQuery(purl)
+	q.Scheme = "tcp"
+	conn, err := sql.Open("clickhouse", q.String())
+	if err != nil {
+		return nil, err
+	}
+
+	ch = &ClickHouse{
+		conn: conn,
+		config: &Config{
+			MigrationsTable:       purl.Query().Get("x-migrations-table"),
+			DatabaseName:          purl.Query().Get("database"),
+			MultiStatementEnabled: purl.Query().Get("x-multi-statement") == "true",
+		},
+	}
+
+	if err := ch.init(); err != nil {
+		return nil, err
+	}
+
+	return ch, nil
+}
+
+func (ch *ClickHouse) init() error {
+	if len(ch.config.DatabaseName) == 0 {
+		if err := ch.conn.QueryRow("SELECT currentDatabase()").Scan(&ch.config.DatabaseName); err != nil {
+			return err
+		}
+	}
+
+	if len(ch.config.MigrationsTable) == 0 {
+		ch.config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	return ch.ensureVersionTable()
+}
+
+func (ch *ClickHouse) Run(r io.Reader) error {
+	migration, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+
+	if ch.config.MultiStatementEnabled {
+		// split query by semi-colon
+		queries := strings.Split(string(migration), ";")
+		for _, q := range queries {
+			tq := strings.TrimSpace(q)
+			if tq == "" {
+				continue
+			}
+			if _, err := ch.conn.Exec(string(q)); err != nil {
+				return database.Error{OrigErr: err, Err: "migration failed", Query: []byte(q)}
+			}
+		}
+		return nil
+	}
+
+	if _, err := ch.conn.Exec(string(migration)); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migration}
+	}
+
+	return nil
+}
+func (ch *ClickHouse) Version() (int, bool, error) {
+	var (
+		version int
+		dirty   uint8
+		query   = "SELECT version, dirty FROM `" + ch.config.MigrationsTable + "` ORDER BY sequence DESC LIMIT 1"
+	)
+	if err := ch.conn.QueryRow(query).Scan(&version, &dirty); err != nil {
+		if err == sql.ErrNoRows {
+			return database.NilVersion, false, nil
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return version, dirty == 1, nil
+}
+
+func (ch *ClickHouse) SetVersion(version int, dirty bool) error {
+	var (
+		bool = func(v bool) uint8 {
+			if v {
+				return 1
+			}
+			return 0
+		}
+		tx, err = ch.conn.Begin()
+	)
+	if err != nil {
+		return err
+	}
+
+	query := "INSERT INTO " + ch.config.MigrationsTable + " (version, dirty, sequence) VALUES (?, ?, ?)"
+	if _, err := tx.Exec(query, version, bool(dirty), time.Now().UnixNano()); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return tx.Commit()
+}
+
+func (ch *ClickHouse) ensureVersionTable() error {
+	var (
+		table string
+		query = "SHOW TABLES FROM " + ch.config.DatabaseName + " LIKE '" + ch.config.MigrationsTable + "'"
+	)
+	// check if migration table exists
+	if err := ch.conn.QueryRow(query).Scan(&table); err != nil {
+		if err != sql.ErrNoRows {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	} else {
+		return nil
+	}
+	// if not, create the empty migration table
+	query = `
+		CREATE TABLE ` + ch.config.MigrationsTable + ` (
+			version    UInt32, 
+			dirty      UInt8,
+			sequence   UInt64
+		) Engine=TinyLog
+	`
+	if _, err := ch.conn.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+func (ch *ClickHouse) Drop() error {
+	var (
+		query       = "SHOW TABLES FROM " + ch.config.DatabaseName
+		tables, err = ch.conn.Query(query)
+	)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+	for tables.Next() {
+		var table string
+		if err := tables.Scan(&table); err != nil {
+			return err
+		}
+
+		query = "DROP TABLE IF EXISTS " + ch.config.DatabaseName + "." + table
+
+		if _, err := ch.conn.Exec(query); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+	return ch.ensureVersionTable()
+}
+
+func (ch *ClickHouse) Lock() error   { return nil }
+func (ch *ClickHouse) Unlock() error { return nil }
+func (ch *ClickHouse) Close() error  { return ch.conn.Close() }

database/clickhouse/examples/migrations/001_init.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS test_1;

database/clickhouse/examples/migrations/001_init.up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE test_1 (
+    Date Date 
+) Engine=Memory;

database/clickhouse/examples/migrations/002_create_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS test_2;

database/clickhouse/examples/migrations/002_create_table.up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE test_2 (
+    Date Date 
+) Engine=Memory;

database/cockroachdb/README.md

@@ -0,0 +1,19 @@
+# cockroachdb
+
+`cockroachdb://user:password@host:port/dbname?query` (`cockroach://`, and `crdb-postgres://` work, too)
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `x-lock-table` | `LockTable` | Name of the table which maintains the migration lock |
+| `x-force-lock` | `ForceLock` | Force lock acquisition to fix faulty migrations which may not have released the schema lock (Boolean, default is `false`) |
+| `dbname` | `DatabaseName` | The name of the database to connect to |
+| `user` | | The user to sign in as |
+| `password` | | The user's password |
+| `host` | | The host to connect to. Values that start with / are for unix domain sockets. (default is localhost) |
+| `port` | | The port to bind to. (default is 5432) |
+| `connect_timeout` | | Maximum wait for connection, in seconds. Zero or not specified means wait indefinitely. |
+| `sslcert` | | Cert file location. The file must contain PEM encoded data. |
+| `sslkey` | | Key file location. The file must contain PEM encoded data. |
+| `sslrootcert` | | The location of the root certificate file. The file must contain PEM encoded data. |
+| `sslmode` | | Whether or not to use SSL (disable\|require\|verify-ca\|verify-full) |

database/cockroachdb/cockroachdb.go

@@ -0,0 +1,342 @@
+package cockroachdb
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"regexp"
+	"strconv"
+)
+
+import (
+	"github.com/cockroachdb/cockroach-go/crdb"
+	"github.com/lib/pq"
+)
+
+import (
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+)
+
+func init() {
+	db := CockroachDb{}
+	database.Register("cockroach", &db)
+	database.Register("cockroachdb", &db)
+	database.Register("crdb-postgres", &db)
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+var DefaultLockTable = "schema_lock"
+
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+)
+
+type Config struct {
+	MigrationsTable string
+	LockTable       string
+	ForceLock       bool
+	DatabaseName    string
+}
+
+type CockroachDb struct {
+	db       *sql.DB
+	isLocked bool
+
+	// Open and WithInstance need to guarantee that config is never nil
+	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
+	}
+
+	query := `SELECT current_database()`
+	var databaseName string
+	if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(databaseName) == 0 {
+		return nil, ErrNoDatabaseName
+	}
+
+	config.DatabaseName = databaseName
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	if len(config.LockTable) == 0 {
+		config.LockTable = DefaultLockTable
+	}
+
+	px := &CockroachDb{
+		db:     instance,
+		config: config,
+	}
+
+	if err := px.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	if err := px.ensureLockTable(); err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (c *CockroachDb) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// As Cockroach uses the postgres protocol, and 'postgres' is already a registered database, we need to replace the
+	// connect prefix, with the actual protocol, so that the library can differentiate between the implementations
+	re := regexp.MustCompile("^(cockroach(db)?|crdb-postgres)")
+	connectString := re.ReplaceAllString(migrate.FilterCustomQuery(purl).String(), "postgres")
+
+	db, err := sql.Open("postgres", connectString)
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	lockTable := purl.Query().Get("x-lock-table")
+	if len(lockTable) == 0 {
+		lockTable = DefaultLockTable
+	}
+
+	forceLockQuery := purl.Query().Get("x-force-lock")
+	forceLock, err := strconv.ParseBool(forceLockQuery)
+	if err != nil {
+		forceLock = false
+	}
+
+	px, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+		LockTable:       lockTable,
+		ForceLock:       forceLock,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (c *CockroachDb) Close() error {
+	return c.db.Close()
+}
+
+// Locking is done manually with a separate lock table.  Implementing advisory locks in CRDB is being discussed
+// See: https://github.com/cockroachdb/cockroach/issues/13546
+func (c *CockroachDb) Lock() error {
+	err := crdb.ExecuteTx(context.Background(), c.db, nil, func(tx *sql.Tx) error {
+		aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+		if err != nil {
+			return err
+		}
+
+		query := "SELECT * FROM " + c.config.LockTable + " WHERE lock_id = $1"
+		rows, err := tx.Query(query, aid)
+		if err != nil {
+			return database.Error{OrigErr: err, Err: "failed to fetch migration lock", Query: []byte(query)}
+		}
+		defer rows.Close()
+
+		// If row exists at all, lock is present
+		locked := rows.Next()
+		if locked && !c.config.ForceLock {
+			return database.ErrLocked
+		}
+
+		query = "INSERT INTO " + c.config.LockTable + " (lock_id) VALUES ($1)"
+		if _, err := tx.Exec(query, aid); err != nil {
+			return database.Error{OrigErr: err, Err: "failed to set migration lock", Query: []byte(query)}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	} else {
+		c.isLocked = true
+		return nil
+	}
+}
+
+// Locking is done manually with a separate lock table.  Implementing advisory locks in CRDB is being discussed
+// See: https://github.com/cockroachdb/cockroach/issues/13546
+func (c *CockroachDb) Unlock() error {
+	aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	// In the event of an implementation (non-migration) error, it is possible for the lock to not be released.  Until
+	// a better locking mechanism is added, a manual purging of the lock table may be required in such circumstances
+	query := "DELETE FROM " + c.config.LockTable + " WHERE lock_id = $1"
+	if _, err := c.db.Exec(query, aid); err != nil {
+		if e, ok := err.(*pq.Error); ok {
+			// 42P01 is "UndefinedTableError" in CockroachDB
+			// https://github.com/cockroachdb/cockroach/blob/master/pkg/sql/pgwire/pgerror/codes.go
+			if e.Code == "42P01" {
+				// On drops, the lock table is fully removed;  This is fine, and is a valid "unlocked" state for the schema
+				c.isLocked = false
+				return nil
+			}
+		}
+		return database.Error{OrigErr: err, Err: "failed to release migration lock", Query: []byte(query)}
+	}
+
+	c.isLocked = false
+	return nil
+}
+
+func (c *CockroachDb) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	// run migration
+	query := string(migr[:])
+	if _, err := c.db.Exec(query); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+func (c *CockroachDb) SetVersion(version int, dirty bool) error {
+	return crdb.ExecuteTx(context.Background(), c.db, nil, func(tx *sql.Tx) error {
+		if _, err := tx.Exec(`DELETE FROM "` + c.config.MigrationsTable + `"`); err != nil {
+			return err
+		}
+
+		if version >= 0 {
+			if _, err := tx.Exec(`INSERT INTO "`+c.config.MigrationsTable+`" (version, dirty) VALUES ($1, $2)`, version, dirty); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func (c *CockroachDb) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM "` + c.config.MigrationsTable + `" LIMIT 1`
+	err = c.db.QueryRow(query).Scan(&version, &dirty)
+
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*pq.Error); ok {
+			// 42P01 is "UndefinedTableError" in CockroachDB
+			// https://github.com/cockroachdb/cockroach/blob/master/pkg/sql/pgwire/pgerror/codes.go
+			if e.Code == "42P01" {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (c *CockroachDb) Drop() error {
+	// select all tables in current schema
+	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema())`
+	tables, err := c.db.Query(query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+
+	// delete one table after another
+	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 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = `DROP TABLE IF EXISTS ` + t + ` CASCADE`
+			if _, err := c.db.Exec(query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+		if err := c.ensureVersionTable(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *CockroachDb) ensureVersionTable() error {
+	// check if migration table exists
+	var count int
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
+	if err := c.db.QueryRow(query, c.config.MigrationsTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	// if not, create the empty migration table
+	query = `CREATE TABLE "` + c.config.MigrationsTable + `" (version INT NOT NULL PRIMARY KEY, dirty BOOL NOT NULL)`
+	if _, err := c.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+func (c *CockroachDb) ensureLockTable() error {
+	// check if lock table exists
+	var count int
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
+	if err := c.db.QueryRow(query, c.config.LockTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	// if not, create the empty lock table
+	query = `CREATE TABLE "` + c.config.LockTable + `" (lock_id INT NOT NULL PRIMARY KEY)`
+	if _, err := c.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}

database/cockroachdb/cockroachdb_test.go

@@ -0,0 +1,91 @@
+package cockroachdb
+
+// error codes https://github.com/lib/pq/blob/master/error.go
+
+import (
+	//"bytes"
+	"database/sql"
+	"fmt"
+	"io"
+	"testing"
+
+	"github.com/lib/pq"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
+	"bytes"
+)
+
+var versions = []mt.Version{
+	{Image: "cockroachdb/cockroach:v1.0.2", Cmd: []string{"start", "--insecure"}},
+}
+
+func isReady(i mt.Instance) bool {
+	db, err := sql.Open("postgres", fmt.Sprintf("postgres://root@%v:%v?sslmode=disable", i.Host(), i.PortFor(26257)))
+	if err != nil {
+		return false
+	}
+	defer db.Close()
+	err = db.Ping()
+	if err == io.EOF {
+		_, err = db.Exec("CREATE DATABASE migrate")
+		return err == nil;
+	} else if e, ok := err.(*pq.Error); ok {
+		if e.Code.Name() == "cannot_connect_now" {
+			return false
+		}
+	}
+
+	_, err = db.Exec("CREATE DATABASE migrate")
+	return err == nil;
+
+	return true
+}
+
+func Test(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable", i.Host(), i.PortFor(26257))
+			d, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			dt.Test(t, d, []byte("SELECT 1"))
+		})
+}
+
+func TestMultiStatement(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable", i.Host(), i.Port())
+			d, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			if err := d.Run(bytes.NewReader([]byte("CREATE TABLE foo (foo text); CREATE TABLE bar (bar text);"))); err != nil {
+				t.Fatalf("expected err to be nil, got %v", err)
+			}
+
+			// make sure second table exists
+			var exists bool
+			if err := d.(*CockroachDb).db.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bar' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+				t.Fatal(err)
+			}
+			if !exists {
+				t.Fatalf("expected table bar to exist")
+			}
+		})
+}
+
+func TestFilterCustomQuery(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable&x-custom=foobar", i.Host(), i.PortFor(26257))
+			_, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+		})
+}

database/cockroachdb/examples/migrations/1085649617_create_users_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;

database/cockroachdb/examples/migrations/1085649617_create_users_table.up.sql

@@ -0,0 +1,5 @@
+CREATE TABLE users (
+  user_id INT UNIQUE,
+  name    STRING(40),
+  email   STRING(40)
+);

database/cockroachdb/examples/migrations/1185749658_add_city_to_users.down.sql

@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS city;

database/cockroachdb/examples/migrations/1185749658_add_city_to_users.up.sql

@@ -0,0 +1 @@
+ALTER TABLE users ADD COLUMN city TEXT;

database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.down.sql

@@ -0,0 +1 @@
+DROP INDEX IF EXISTS users_email_index;

database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.up.sql

@@ -0,0 +1,3 @@
+CREATE UNIQUE INDEX IF NOT EXISTS users_email_index ON users (email);
+
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.

database/cockroachdb/examples/migrations/1385949617_create_books_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS books;

database/cockroachdb/examples/migrations/1385949617_create_books_table.up.sql

@@ -0,0 +1,5 @@
+CREATE TABLE books (
+  user_id INT,
+  name    STRING(40),
+  author  STRING(40)
+);

database/cockroachdb/examples/migrations/1485949617_create_movies_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS movies;

database/cockroachdb/examples/migrations/1485949617_create_movies_table.up.sql

@@ -0,0 +1,5 @@
+CREATE TABLE movies (
+  user_id   INT,
+  name      STRING(40),
+  director  STRING(40)
+);

database/cockroachdb/examples/migrations/1585849751_just_a_comment.up.sql

@@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.

database/cockroachdb/examples/migrations/1685849751_another_comment.up.sql

@@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.

database/cockroachdb/examples/migrations/1785849751_another_comment.up.sql

@@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.

database/cockroachdb/examples/migrations/1885849751_another_comment.up.sql

@@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.

database/driver.go

@@ -32,6 +32,8 @@ var drivers = make(map[string]Driver)
 //      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.
@@ -71,7 +73,7 @@ type Driver interface {
 	// Dirty means, a previous migration failed and user interaction is required.
 	Version() (version int, dirty bool, err error)
 
-	// Drop deletes everyting in the database.
+	// Drop deletes everything in the database.
 	Drop() error
 }
 
@@ -79,7 +81,8 @@ type Driver interface {
 func Open(url string) (Driver, error) {
 	u, err := nurl.Parse(url)
 	if err != nil {
-		return nil, err
+		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 == "" {
@@ -90,7 +93,7 @@ func Open(url string) (Driver, error) {
 	d, ok := drivers[u.Scheme]
 	driversMu.RUnlock()
 	if !ok {
-		return nil, fmt.Errorf("database driver: unknown driver %v (forgotton import?)", u.Scheme)
+		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", u.Scheme)
 	}
 
 	return d.Open(url)
@@ -108,3 +111,14 @@ func Register(name string, driver Driver) {
 	}
 	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
+}

database/mysql/README.md

@@ -1,24 +1,54 @@
-# mysql
-
-`mysql://user:password@tcp(host:port)/dbname?query`
-
-| URL Query  | WithInstance Config | Description |
-|------------|---------------------|-------------|
-| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
-| `dbname` | `DatabaseName` | The name of the database to connect to |
-| `user` | | The user to sign in as |
-| `password` | | The user's password | 
-| `host` | | The host to connect to. |
-| `port` | | The port to bind to. |
-| `x-tls-ca` | | The location of the root certificate file. |
-| `x-tls-cert` | | Cert file location. |
-| `x-tls-key` | | Key file location. | 
-| `x-tls-insecure-skip-verify` | | Whether or not to use SSL (true\|false) | 
-
-## Upgrading from v1
-
-1. Write down the current migration version from schema_migrations
-1. `DROP TABLE schema_migrations`
-2. Wrap your existing migrations in transactions ([BEGIN/COMMIT](https://dev.mysql.com/doc/refman/5.7/en/commit.html)) if you use multiple statements within one migration.
-3. Download and install the latest migrate version.
-4. Force the current migration version with `migrate force <current_version>`.
+# MySQL
+
+`mysql://user:password@tcp(host:port)/dbname?query`
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `dbname` | `DatabaseName` | The name of the database to connect to |
+| `user` | | The user to sign in as |
+| `password` | | The user's password | 
+| `host` | | The host to connect to. |
+| `port` | | The port to bind to. |
+| `tls`  | | TLS / SSL encrypted connection parameter; see [go-sql-driver](https://github.com/go-sql-driver/mysql#tls). Use any name (e.g. `migrate`) if you want to use a custom TLS config (`x-tls-` queries). |
+| `x-tls-ca` | | The location of the CA (certificate authority) file. |
+| `x-tls-cert` | | The location of the client certicicate file. Must be used with `x-tls-key`. |
+| `x-tls-key` | | The location of the private key file. Must be used with `x-tls-cert`. |
+| `x-tls-insecure-skip-verify` | | Whether or not to use SSL (true\|false) | 
+
+## Use with existing client
+
+If you use the MySQL driver with existing database client, you must create the client with parameter `multiStatements=true`:
+
+```go
+package main
+
+import (
+    "database/sql"
+    
+    _ "github.com/go-sql-driver/mysql"
+    "github.com/golang-migrate/migrate"
+    "github.com/golang-migrate/migrate/database/mysql"
+    _ "github.com/golang-migrate/migrate/source/file"
+)
+
+func main() {
+    db, _ := sql.Open("mysql", "user:password@tcp(host:port)/dbname?multiStatements=true")
+    driver, _ := mysql.WithInstance(db, &mysql.Config{})
+    m, _ := migrate.NewWithDatabaseInstance(
+        "file:///migrations",
+        "mysql", 
+        driver,
+    )
+    
+    m.Steps(2)
+}
+```
+
+## Upgrading from v1
+
+1. Write down the current migration version from schema_migrations
+1. `DROP TABLE schema_migrations`
+2. Wrap your existing migrations in transactions ([BEGIN/COMMIT](https://dev.mysql.com/doc/refman/5.7/en/commit.html)) if you use multiple statements within one migration.
+3. Download and install the latest migrate version.
+4. Force the current migration version with `migrate force <current_version>`.

database/mysql/mysql.go

@@ -1,6 +1,9 @@
+// +build go1.9
+
 package mysql
 
 import (
+	"context"
 	"crypto/tls"
 	"crypto/x509"
 	"database/sql"
@@ -10,10 +13,15 @@ import (
 	nurl "net/url"
 	"strconv"
 	"strings"
+)
 
+import (
 	"github.com/go-sql-driver/mysql"
-	"github.com/mattes/migrate"
-	"github.com/mattes/migrate/database"
+)
+
+import (
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
 )
 
 func init() {
@@ -27,6 +35,7 @@ var (
 	ErrNilConfig      = fmt.Errorf("no config")
 	ErrNoDatabaseName = fmt.Errorf("no database name")
 	ErrAppendPEM      = fmt.Errorf("failed to append PEM")
+	ErrTLSCertKeyConfig = fmt.Errorf("To use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")
 )
 
 type Config struct {
@@ -35,7 +44,9 @@ type Config struct {
 }
 
 type Mysql struct {
-	db       *sql.DB
+	// mysql RELEASE_LOCK must be called from the same conn, so
+	// just do everything over a single conn anyway.
+	conn     *sql.Conn
 	isLocked bool
 
 	config *Config
@@ -67,8 +78,13 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
 		config.MigrationsTable = DefaultMigrationsTable
 	}
 
+	conn, err := instance.Conn(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
 	mx := &Mysql{
-		db:     instance,
+		conn:   conn,
 		config: config,
 	}
 
@@ -79,6 +95,25 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
 	return mx, nil
 }
 
+// urlToMySQLConfig takes a net/url URL and returns a go-sql-driver/mysql Config.
+// Manually sets username and password to avoid net/url from url-encoding the reserved URL characters
+func urlToMySQLConfig(u nurl.URL) (*mysql.Config, error) {
+	origUserInfo := u.User
+	u.User = nil
+
+	c, err := mysql.ParseDSN(strings.TrimPrefix(u.String(), "mysql://"))
+	if err != nil {
+		return nil, err
+	}
+	if origUserInfo != nil {
+		c.User = origUserInfo.Username()
+		if p, ok := origUserInfo.Password(); ok {
+			c.Passwd = p
+		}
+	}
+	return c, nil
+}
+
 func (m *Mysql) Open(url string) (database.Driver, error) {
 	purl, err := nurl.Parse(url)
 	if err != nil {
@@ -89,12 +124,6 @@ func (m *Mysql) Open(url string) (database.Driver, error) {
 	q.Set("multiStatements", "true")
 	purl.RawQuery = q.Encode()
 
-	db, err := sql.Open("mysql", strings.Replace(
-		migrate.FilterCustomQuery(purl).String(), "mysql://", "", 1))
-	if err != nil {
-		return nil, err
-	}
-
 	migrationsTable := purl.Query().Get("x-migrations-table")
 	if len(migrationsTable) == 0 {
 		migrationsTable = DefaultMigrationsTable
@@ -114,9 +143,16 @@ func (m *Mysql) Open(url string) (database.Driver, error) {
 				return nil, ErrAppendPEM
 			}
 
-			certs, err := tls.LoadX509KeyPair(purl.Query().Get("x-tls-cert"), purl.Query().Get("x-tls-key"))
-			if err != nil {
-				return nil, err
+			clientCert := make([]tls.Certificate, 0, 1)
+			if ccert, ckey := purl.Query().Get("x-tls-cert"), purl.Query().Get("x-tls-key"); ccert != "" || ckey != "" {
+				if ccert == "" || ckey == "" {
+					return nil, ErrTLSCertKeyConfig
+				}
+				certs, err := tls.LoadX509KeyPair(ccert, ckey)
+				if err != nil {
+					return nil, err
+				}
+				clientCert = append(clientCert, certs)
 			}
 
 			insecureSkipVerify := false
@@ -130,12 +166,21 @@ func (m *Mysql) Open(url string) (database.Driver, error) {
 
 			mysql.RegisterTLSConfig(ctls, &tls.Config{
 				RootCAs:            rootCertPool,
-				Certificates:       []tls.Certificate{certs},
+				Certificates:       clientCert,
 				InsecureSkipVerify: insecureSkipVerify,
 			})
 		}
 	}
 
+	c, err := urlToMySQLConfig(*migrate.FilterCustomQuery(purl))
+	if err != nil {
+		return nil, err
+	}
+	db, err := sql.Open("mysql", c.FormatDSN())
+	if err != nil {
+		return nil, err
+	}
+
 	mx, err := WithInstance(db, &Config{
 		DatabaseName:    purl.Path,
 		MigrationsTable: migrationsTable,
@@ -148,7 +193,7 @@ func (m *Mysql) Open(url string) (database.Driver, error) {
 }
 
 func (m *Mysql) Close() error {
-	return m.db.Close()
+	return m.conn.Close()
 }
 
 func (m *Mysql) Lock() error {
@@ -156,14 +201,15 @@ func (m *Mysql) Lock() error {
 		return database.ErrLocked
 	}
 
-	aid, err := database.GenerateAdvisoryLockId(m.config.DatabaseName)
+	aid, err := database.GenerateAdvisoryLockId(
+		fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
 	if err != nil {
 		return err
 	}
 
-	query := "SELECT GET_LOCK(?, 1)"
+	query := "SELECT GET_LOCK(?, 10)"
 	var success bool
-	if err := m.db.QueryRow(query, aid).Scan(&success); err != nil {
+	if err := m.conn.QueryRowContext(context.Background(), query, aid).Scan(&success); err != nil {
 		return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}
 	}
 
@@ -180,16 +226,21 @@ func (m *Mysql) Unlock() error {
 		return nil
 	}
 
-	aid, err := database.GenerateAdvisoryLockId(m.config.DatabaseName)
+	aid, err := database.GenerateAdvisoryLockId(
+		fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
 	if err != nil {
 		return err
 	}
 
 	query := `SELECT RELEASE_LOCK(?)`
-	if _, err := m.db.Exec(query, aid); err != nil {
+	if _, err := m.conn.ExecContext(context.Background(), query, aid); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 
+	// NOTE: RELEASE_LOCK could return NULL or (or 0 if the code is changed),
+	// in which case isLocked should be true until the timeout expires -- synchronizing
+	// these states is likely not worth trying to do; reconsider the necessity of isLocked.
+
 	m.isLocked = false
 	return nil
 }
@@ -201,7 +252,7 @@ func (m *Mysql) Run(migration io.Reader) error {
 	}
 
 	query := string(migr[:])
-	if _, err := m.db.Exec(query); err != nil {
+	if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
 		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
 	}
 
@@ -209,19 +260,20 @@ func (m *Mysql) Run(migration io.Reader) error {
 }
 
 func (m *Mysql) SetVersion(version int, dirty bool) error {
-	tx, err := m.db.Begin()
+	tx, err := m.conn.BeginTx(context.Background(), &sql.TxOptions{})
 	if err != nil {
 		return &database.Error{OrigErr: err, Err: "transaction start failed"}
 	}
 
 	query := "TRUNCATE `" + m.config.MigrationsTable + "`"
-	if _, err := m.db.Exec(query); err != nil {
+	if _, err := tx.ExecContext(context.Background(), query); err != nil {
+		tx.Rollback()
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 
 	if version >= 0 {
 		query := "INSERT INTO `" + m.config.MigrationsTable + "` (version, dirty) VALUES (?, ?)"
-		if _, err := m.db.Exec(query, version, dirty); err != nil {
+		if _, err := tx.ExecContext(context.Background(), query, version, dirty); err != nil {
 			tx.Rollback()
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -236,7 +288,7 @@ func (m *Mysql) SetVersion(version int, dirty bool) error {
 
 func (m *Mysql) 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)
+	err = m.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
 	switch {
 	case err == sql.ErrNoRows:
 		return database.NilVersion, false, nil
@@ -257,7 +309,7 @@ func (m *Mysql) Version() (version int, dirty bool, err error) {
 func (m *Mysql) Drop() error {
 	// select all tables
 	query := `SHOW TABLES LIKE '%'`
-	tables, err := m.db.Query(query)
+	tables, err := m.conn.QueryContext(context.Background(), query)
 	if err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -279,7 +331,7 @@ func (m *Mysql) Drop() error {
 		// delete one by one ...
 		for _, t := range tableNames {
 			query = "DROP TABLE IF EXISTS `" + t + "` CASCADE"
-			if _, err := m.db.Exec(query); err != nil {
+			if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
 				return &database.Error{OrigErr: err, Query: []byte(query)}
 			}
 		}
@@ -295,7 +347,7 @@ func (m *Mysql) ensureVersionTable() error {
 	// check if migration table exists
 	var result string
 	query := `SHOW TABLES LIKE "` + m.config.MigrationsTable + `"`
-	if err := m.db.QueryRow(query).Scan(&result); err != nil {
+	if err := m.conn.QueryRowContext(context.Background(), query).Scan(&result); err != nil {
 		if err != sql.ErrNoRows {
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -305,7 +357,7 @@ func (m *Mysql) ensureVersionTable() error {
 
 	// if not, create the empty migration table
 	query = "CREATE TABLE `" + m.config.MigrationsTable + "` (version bigint not null primary key, dirty boolean not null)"
-	if _, err := m.db.Exec(query); err != nil {
+	if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 	return nil

database/mysql/mysql_test.go

@@ -4,20 +4,24 @@ import (
 	"database/sql"
 	sqldriver "database/sql/driver"
 	"fmt"
-	// "io/ioutil"
-	// "log"
+	"net/url"
 	"testing"
+)
 
-	// "github.com/go-sql-driver/mysql"
-	dt "github.com/mattes/migrate/database/testing"
-	mt "github.com/mattes/migrate/testing"
+import (
+	"github.com/go-sql-driver/mysql"
+)
+
+import (
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
 )
 
 var versions = []mt.Version{
-	{"mysql:8", []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
-	{"mysql:5.7", []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
-	{"mysql:5.6", []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
-	{"mysql:5.5", []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:8", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.7", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.6", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.5", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
 }
 
 func isReady(i mt.Instance) bool {
@@ -26,9 +30,13 @@ func isReady(i mt.Instance) bool {
 		return false
 	}
 	defer db.Close()
-	err = db.Ping()
-
-	if err == sqldriver.ErrBadConn {
+	if err = db.Ping(); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn, mysql.ErrInvalidConn:
+			return false
+		default:
+			fmt.Println(err)
+		}
 		return false
 	}
 
@@ -46,6 +54,7 @@ func Test(t *testing.T) {
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d.Close()
 			dt.Test(t, d, []byte("SELECT 1"))
 
 			// check ensureVersionTable
@@ -58,3 +67,89 @@ func Test(t *testing.T) {
 			}
 		})
 }
+
+func TestLockWorks(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Mysql{}
+			addr := fmt.Sprintf("mysql://root:root@tcp(%v:%v)/public", i.Host(), i.Port())
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			dt.Test(t, d, []byte("SELECT 1"))
+
+			ms := d.(*Mysql)
+
+			err = ms.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = ms.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// make sure the 2nd lock works (RELEASE_LOCK is very finicky)
+			err = ms.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = ms.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+}
+
+func TestURLToMySQLConfig(t *testing.T) {
+	testcases := []struct {
+		name        string
+		urlStr      string
+		expectedDSN string // empty string signifies that an error is expected
+	}{
+		{name: "no user/password", urlStr: "mysql://tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "only user", urlStr: "mysql://username@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "only user - with encoded :",
+			urlStr:      "mysql://username%3A@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username:@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "only user - with encoded @",
+			urlStr:      "mysql://username%40@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username@@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "user/password", urlStr: "mysql://username:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		// Not supported yet: https://github.com/go-sql-driver/mysql/issues/591
+		// {name: "user/password - user with encoded :",
+		// 	urlStr:      "mysql://username%3A:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+		// 	expectedDSN: "username::pasword@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "user/password - user with encoded @",
+			urlStr:      "mysql://username%40:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username@:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "user/password - password with encoded :",
+			urlStr:      "mysql://username:password%3A@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username:password:@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+		{name: "user/password - password with encoded @",
+			urlStr:      "mysql://username:password%40@tcp(127.0.0.1:3306)/myDB?multiStatements=true",
+			expectedDSN: "username:password@@tcp(127.0.0.1:3306)/myDB?multiStatements=true"},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			u, err := url.Parse(tc.urlStr)
+			if err != nil {
+				t.Fatal("Failed to parse url string:", tc.urlStr, "error:", err)
+			}
+			if config, err := urlToMySQLConfig(*u); err == nil {
+				dsn := config.FormatDSN()
+				if dsn != tc.expectedDSN {
+					t.Error("Got unexpected DSN:", dsn, "!=", tc.expectedDSN)
+				}
+			} else {
+				if tc.expectedDSN != "" {
+					t.Error("Got unexpected error:", err, "urlStr:", tc.urlStr)
+				}
+			}
+		})
+	}
+}

database/parse_test.go

@@ -0,0 +1,244 @@
+package database_test
+
+import (
+	"encoding/hex"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+const reservedChars = "!#$%&'()*+,/:;=?@[]"
+
+// TestUserUnencodedReservedURLChars documents the behavior of using unencoded reserved characters in usernames with
+// net/url Parse()
+func TestUserUnencodedReservedURLChars(t *testing.T) {
+	scheme := "database://"
+	baseUsername := "username"
+	urlSuffix := "password@localhost:12345/myDB?someParam=true"
+	urlSuffixAndSep := ":" + urlSuffix
+
+	testcases := []struct {
+		char             string
+		parses           bool
+		expectedUsername string // empty string means that the username failed to parse
+		encodedURL       string
+	}{
+		{char: "!", parses: true, expectedUsername: baseUsername + "!",
+			encodedURL: scheme + baseUsername + "%21" + urlSuffixAndSep},
+		{char: "#", parses: true, expectedUsername: "",
+			encodedURL: scheme + baseUsername + "#" + urlSuffixAndSep},
+		{char: "$", parses: true, expectedUsername: baseUsername + "$",
+			encodedURL: scheme + baseUsername + "$" + urlSuffixAndSep},
+		{char: "%", parses: false},
+		{char: "&", parses: true, expectedUsername: baseUsername + "&",
+			encodedURL: scheme + baseUsername + "&" + urlSuffixAndSep},
+		{char: "'", parses: true, expectedUsername: "username'",
+			encodedURL: scheme + baseUsername + "%27" + urlSuffixAndSep},
+		{char: "(", parses: true, expectedUsername: "username(",
+			encodedURL: scheme + baseUsername + "%28" + urlSuffixAndSep},
+		{char: ")", parses: true, expectedUsername: "username)",
+			encodedURL: scheme + baseUsername + "%29" + urlSuffixAndSep},
+		{char: "*", parses: true, expectedUsername: "username*",
+			encodedURL: scheme + baseUsername + "%2A" + urlSuffixAndSep},
+		{char: "+", parses: true, expectedUsername: "username+",
+			encodedURL: scheme + baseUsername + "+" + urlSuffixAndSep},
+		{char: ",", parses: true, expectedUsername: "username,",
+			encodedURL: scheme + baseUsername + "," + urlSuffixAndSep},
+		{char: "/", parses: true, expectedUsername: "",
+			encodedURL: scheme + baseUsername + "/" + urlSuffixAndSep},
+		{char: ":", parses: true, expectedUsername: "username",
+			encodedURL: scheme + baseUsername + ":%3A" + urlSuffix},
+		{char: ";", parses: true, expectedUsername: "username;",
+			encodedURL: scheme + baseUsername + ";" + urlSuffixAndSep},
+		{char: "=", parses: true, expectedUsername: "username=",
+			encodedURL: scheme + baseUsername + "=" + urlSuffixAndSep},
+		{char: "?", parses: true, expectedUsername: "",
+			encodedURL: scheme + baseUsername + "?" + urlSuffixAndSep},
+		{char: "@", parses: true, expectedUsername: "username@",
+			encodedURL: scheme + baseUsername + "%40" + urlSuffixAndSep},
+		{char: "[", parses: false},
+		{char: "]", parses: false},
+	}
+
+	testedChars := make([]string, 0, len(reservedChars))
+	for _, tc := range testcases {
+		testedChars = append(testedChars, tc.char)
+		t.Run("reserved char "+tc.char, func(t *testing.T) {
+			s := scheme + baseUsername + tc.char + urlSuffixAndSep
+			u, err := url.Parse(s)
+			if err == nil {
+				if !tc.parses {
+					t.Error("Unexpectedly parsed reserved character. url:", s)
+					return
+				}
+				var username string
+				if u.User != nil {
+					username = u.User.Username()
+				}
+				if username != tc.expectedUsername {
+					t.Error("Got unexpected username:", username, "!=", tc.expectedUsername)
+				}
+				if s := u.String(); s != tc.encodedURL {
+					t.Error("Got unexpected encoded URL:", s, "!=", tc.encodedURL)
+				}
+			} else {
+				if tc.parses {
+					t.Error("Failed to parse reserved character. url:", s)
+				}
+			}
+		})
+	}
+
+	t.Run("All reserved chars tested", func(t *testing.T) {
+		if s := strings.Join(testedChars, ""); s != reservedChars {
+			t.Error("Not all reserved URL characters were tested:", s, "!=", reservedChars)
+		}
+	})
+}
+
+func TestUserEncodedReservedURLChars(t *testing.T) {
+	scheme := "database://"
+	baseUsername := "username"
+	urlSuffix := "password@localhost:12345/myDB?someParam=true"
+	urlSuffixAndSep := ":" + urlSuffix
+
+	for _, c := range reservedChars {
+		c := string(c)
+		t.Run("reserved char "+c, func(t *testing.T) {
+			encodedChar := "%" + hex.EncodeToString([]byte(c))
+			s := scheme + baseUsername + encodedChar + urlSuffixAndSep
+			expectedUsername := baseUsername + c
+			u, err := url.Parse(s)
+			if err != nil {
+				t.Fatal("Failed to parse url with encoded reserved character. url:", s)
+			}
+			if u.User == nil {
+				t.Fatal("Failed to parse userinfo with encoded reserve character. url:", s)
+			}
+			if username := u.User.Username(); username != expectedUsername {
+				t.Fatal("Got unexpected username:", username, "!=", expectedUsername)
+			}
+		})
+	}
+}
+
+// TestPasswordUnencodedReservedURLChars documents the behavior of using unencoded reserved characters in passwords
+// with net/url Parse()
+func TestPasswordUnencodedReservedURLChars(t *testing.T) {
+	username := "username"
+	schemeAndUsernameAndSep := "database://" + username + ":"
+	basePassword := "password"
+	urlSuffixAndSep := "@localhost:12345/myDB?someParam=true"
+
+	testcases := []struct {
+		char             string
+		parses           bool
+		expectedUsername string // empty string means that the username failed to parse
+		expectedPassword string // empty string means that the password failed to parse
+		encodedURL       string
+	}{
+		{char: "!", parses: true, expectedUsername: username, expectedPassword: basePassword + "!",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%21" + urlSuffixAndSep},
+		{char: "#", parses: true, expectedUsername: "", expectedPassword: "",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "#" + urlSuffixAndSep},
+		{char: "$", parses: true, expectedUsername: username, expectedPassword: basePassword + "$",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "$" + urlSuffixAndSep},
+		{char: "%", parses: false},
+		{char: "&", parses: true, expectedUsername: username, expectedPassword: basePassword + "&",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "&" + urlSuffixAndSep},
+		{char: "'", parses: true, expectedUsername: username, expectedPassword: "password'",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%27" + urlSuffixAndSep},
+		{char: "(", parses: true, expectedUsername: username, expectedPassword: "password(",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%28" + urlSuffixAndSep},
+		{char: ")", parses: true, expectedUsername: username, expectedPassword: "password)",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%29" + urlSuffixAndSep},
+		{char: "*", parses: true, expectedUsername: username, expectedPassword: "password*",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%2A" + urlSuffixAndSep},
+		{char: "+", parses: true, expectedUsername: username, expectedPassword: "password+",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "+" + urlSuffixAndSep},
+		{char: ",", parses: true, expectedUsername: username, expectedPassword: "password,",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "," + urlSuffixAndSep},
+		{char: "/", parses: true, expectedUsername: "", expectedPassword: "",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "/" + urlSuffixAndSep},
+		{char: ":", parses: true, expectedUsername: username, expectedPassword: "password:",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%3A" + urlSuffixAndSep},
+		{char: ";", parses: true, expectedUsername: username, expectedPassword: "password;",
+			encodedURL: schemeAndUsernameAndSep + basePassword + ";" + urlSuffixAndSep},
+		{char: "=", parses: true, expectedUsername: username, expectedPassword: "password=",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "=" + urlSuffixAndSep},
+		{char: "?", parses: true, expectedUsername: "", expectedPassword: "",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "?" + urlSuffixAndSep},
+		{char: "@", parses: true, expectedUsername: username, expectedPassword: "password@",
+			encodedURL: schemeAndUsernameAndSep + basePassword + "%40" + urlSuffixAndSep},
+		{char: "[", parses: false},
+		{char: "]", parses: false},
+	}
+
+	testedChars := make([]string, 0, len(reservedChars))
+	for _, tc := range testcases {
+		testedChars = append(testedChars, tc.char)
+		t.Run("reserved char "+tc.char, func(t *testing.T) {
+			s := schemeAndUsernameAndSep + basePassword + tc.char + urlSuffixAndSep
+			u, err := url.Parse(s)
+			if err == nil {
+				if !tc.parses {
+					t.Error("Unexpectedly parsed reserved character. url:", s)
+					return
+				}
+				var username, password string
+				if u.User != nil {
+					username = u.User.Username()
+					password, _ = u.User.Password()
+				}
+				if username != tc.expectedUsername {
+					t.Error("Got unexpected username:", username, "!=", tc.expectedUsername)
+				}
+				if password != tc.expectedPassword {
+					t.Error("Got unexpected password:", password, "!=", tc.expectedPassword)
+				}
+				if s := u.String(); s != tc.encodedURL {
+					t.Error("Got unexpected encoded URL:", s, "!=", tc.encodedURL)
+				}
+			} else {
+				if tc.parses {
+					t.Error("Failed to parse reserved character. url:", s)
+				}
+			}
+		})
+	}
+
+	t.Run("All reserved chars tested", func(t *testing.T) {
+		if s := strings.Join(testedChars, ""); s != reservedChars {
+			t.Error("Not all reserved URL characters were tested:", s, "!=", reservedChars)
+		}
+	})
+}
+
+func TestPasswordEncodedReservedURLChars(t *testing.T) {
+	username := "username"
+	schemeAndUsernameAndSep := "database://" + username + ":"
+	basePassword := "password"
+	urlSuffixAndSep := "@localhost:12345/myDB?someParam=true"
+
+	for _, c := range reservedChars {
+		c := string(c)
+		t.Run("reserved char "+c, func(t *testing.T) {
+			encodedChar := "%" + hex.EncodeToString([]byte(c))
+			s := schemeAndUsernameAndSep + basePassword + encodedChar + urlSuffixAndSep
+			expectedPassword := basePassword + c
+			u, err := url.Parse(s)
+			if err != nil {
+				t.Fatal("Failed to parse url with encoded reserved character. url:", s)
+			}
+			if u.User == nil {
+				t.Fatal("Failed to parse userinfo with encoded reserve character. url:", s)
+			}
+			if n := u.User.Username(); n != username {
+				t.Fatal("Got unexpected username:", n, "!=", username)
+			}
+			if p, _ := u.User.Password(); p != expectedPassword {
+				t.Fatal("Got unexpected password:", p, "!=", expectedPassword)
+			}
+		})
+	}
+}

database/postgres/postgres.go

@@ -1,15 +1,20 @@
+// +build go1.9
+
 package postgres
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"io"
 	"io/ioutil"
 	nurl "net/url"
+	"strconv"
+	"strings"
 
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
 	"github.com/lib/pq"
-	"github.com/mattes/migrate"
-	"github.com/mattes/migrate/database"
 )
 
 func init() {
@@ -33,7 +38,8 @@ type Config struct {
 }
 
 type Postgres struct {
-	db       *sql.DB
+	// Locking and unlocking need to use the same connection
+	conn     *sql.Conn
 	isLocked bool
 
 	// Open and WithInstance need to garantuee that config is never nil
@@ -65,8 +71,14 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
 		config.MigrationsTable = DefaultMigrationsTable
 	}
 
+	conn, err := instance.Conn(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
 	px := &Postgres{
-		db:     instance,
+		conn:   conn,
 		config: config,
 	}
 
@@ -105,7 +117,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 }
 
 func (p *Postgres) Close() error {
-	return p.db.Close()
+	return p.conn.Close()
 }
 
 // https://www.postgresql.org/docs/9.6/static/explicit-locking.html#ADVISORY-LOCKS
@@ -121,18 +133,13 @@ func (p *Postgres) Lock() error {
 
 	// This will either obtain the lock immediately and return true,
 	// or return false if the lock cannot be acquired immediately.
-	query := `SELECT pg_try_advisory_lock($1)`
-	var success bool
-	if err := p.db.QueryRow(query, aid).Scan(&success); err != nil {
+	query := `SELECT pg_advisory_lock($1)`
+	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
 		return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}
 	}
 
-	if success {
-		p.isLocked = true
-		return nil
-	}
-
-	return database.ErrLocked
+	p.isLocked = true
+	return nil
 }
 
 func (p *Postgres) Unlock() error {
@@ -146,7 +153,7 @@ func (p *Postgres) Unlock() error {
 	}
 
 	query := `SELECT pg_advisory_unlock($1)`
-	if _, err := p.db.Exec(query, aid); err != nil {
+	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 	p.isLocked = false
@@ -161,29 +168,81 @@ func (p *Postgres) Run(migration io.Reader) error {
 
 	// run migration
 	query := string(migr[:])
-	if _, err := p.db.Exec(query); err != nil {
-		// TODO: cast to postgress error and get line number
+	if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+		if pgErr, ok := err.(*pq.Error); ok {
+			var line uint
+			var col uint
+			var lineColOK bool
+			if pgErr.Position != "" {
+				if pos, err := strconv.ParseUint(pgErr.Position, 10, 64); err == nil {
+					line, col, lineColOK = computeLineFromPos(query, int(pos))
+				}
+			}
+			message := fmt.Sprintf("migration failed: %s", pgErr.Message)
+			if lineColOK {
+				message = fmt.Sprintf("%s (column %d)", message, col)
+			}
+			if pgErr.Detail != "" {
+				message = fmt.Sprintf("%s, %s", message, pgErr.Detail)
+			}
+			return database.Error{OrigErr: err, Err: message, Query: migr, Line: line}
+		}
 		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
 	}
 
 	return nil
 }
 
+func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
+	// replace crlf with lf
+	s = strings.Replace(s, "\r\n", "\n", -1)
+	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
+	runes := []rune(s)
+	if pos > len(runes) {
+		return 0, 0, false
+	}
+	sel := runes[:pos]
+	line = uint(runesCount(sel, newLine) + 1)
+	col = uint(pos - 1 - runesLastIndex(sel, newLine))
+	return line, col, true
+}
+
+const newLine = '\n'
+
+func runesCount(input []rune, target rune) int {
+	var count int
+	for _, r := range input {
+		if r == target {
+			count++
+		}
+	}
+	return count
+}
+
+func runesLastIndex(input []rune, target rune) int {
+	for i := len(input) - 1; i >= 0; i-- {
+		if input[i] == target {
+			return i
+		}
+	}
+	return -1
+}
+
 func (p *Postgres) SetVersion(version int, dirty bool) error {
-	tx, err := p.db.Begin()
+	tx, err := p.conn.BeginTx(context.Background(), &sql.TxOptions{})
 	if err != nil {
 		return &database.Error{OrigErr: err, Err: "transaction start failed"}
 	}
 
 	query := `TRUNCATE "` + p.config.MigrationsTable + `"`
-	if _, err := p.db.Exec(query); err != nil {
+	if _, err := tx.Exec(query); err != nil {
 		tx.Rollback()
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 
 	if version >= 0 {
 		query = `INSERT INTO "` + p.config.MigrationsTable + `" (version, dirty) VALUES ($1, $2)`
-		if _, err := p.db.Exec(query, version, dirty); err != nil {
+		if _, err := tx.Exec(query, version, dirty); err != nil {
 			tx.Rollback()
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -198,7 +257,7 @@ func (p *Postgres) SetVersion(version int, dirty bool) error {
 
 func (p *Postgres) Version() (version int, dirty bool, err error) {
 	query := `SELECT version, dirty FROM "` + p.config.MigrationsTable + `" LIMIT 1`
-	err = p.db.QueryRow(query).Scan(&version, &dirty)
+	err = p.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
 	switch {
 	case err == sql.ErrNoRows:
 		return database.NilVersion, false, nil
@@ -219,7 +278,7 @@ func (p *Postgres) Version() (version int, dirty bool, err error) {
 func (p *Postgres) Drop() error {
 	// select all tables in current schema
 	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema())`
-	tables, err := p.db.Query(query)
+	tables, err := p.conn.QueryContext(context.Background(), query)
 	if err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -241,7 +300,7 @@ func (p *Postgres) Drop() error {
 		// delete one by one ...
 		for _, t := range tableNames {
 			query = `DROP TABLE IF EXISTS ` + t + ` CASCADE`
-			if _, err := p.db.Exec(query); err != nil {
+			if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
 				return &database.Error{OrigErr: err, Query: []byte(query)}
 			}
 		}
@@ -257,7 +316,7 @@ func (p *Postgres) ensureVersionTable() error {
 	// check if migration table exists
 	var count int
 	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
-	if err := p.db.QueryRow(query, p.config.MigrationsTable).Scan(&count); err != nil {
+	if err := p.conn.QueryRowContext(context.Background(), query, p.config.MigrationsTable).Scan(&count); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 	if count == 1 {
@@ -266,7 +325,7 @@ func (p *Postgres) ensureVersionTable() error {
 
 	// if not, create the empty migration table
 	query = `CREATE TABLE "` + p.config.MigrationsTable + `" (version bigint not null primary key, dirty boolean not null)`
-	if _, err := p.db.Exec(query); err != nil {
+	if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 	return nil

database/postgres/postgres_test.go

@@ -4,38 +4,45 @@ package postgres
 
 import (
 	"bytes"
+	"context"
 	"database/sql"
+	sqldriver "database/sql/driver"
 	"fmt"
 	"io"
+	"strconv"
+	"strings"
 	"testing"
 
-	"github.com/lib/pq"
-	dt "github.com/mattes/migrate/database/testing"
-	mt "github.com/mattes/migrate/testing"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
 )
 
 var versions = []mt.Version{
+	{Image: "postgres:10"},
 	{Image: "postgres:9.6"},
 	{Image: "postgres:9.5"},
 	{Image: "postgres:9.4"},
 	{Image: "postgres:9.3"},
-	{Image: "postgres:9.2"},
+}
+
+func pgConnectionString(host string, port uint) string {
+	return fmt.Sprintf("postgres://postgres@%s:%v/postgres?sslmode=disable", host, port)
 }
 
 func isReady(i mt.Instance) bool {
-	db, err := sql.Open("postgres", fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port()))
+	db, err := sql.Open("postgres", pgConnectionString(i.Host(), i.Port()))
 	if err != nil {
 		return false
 	}
 	defer db.Close()
-	err = db.Ping()
-	if err == io.EOF {
-		return false
-
-	} else if e, ok := err.(*pq.Error); ok {
-		if e.Code.Name() == "cannot_connect_now" {
+	if err = db.Ping(); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn, io.EOF:
 			return false
+		default:
+			fmt.Println(err)
 		}
+		return false
 	}
 
 	return true
@@ -45,11 +52,12 @@ func Test(t *testing.T) {
 	mt.ParallelTest(t, versions, isReady,
 		func(t *testing.T, i mt.Instance) {
 			p := &Postgres{}
-			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
+			addr := pgConnectionString(i.Host(), i.Port())
 			d, err := p.Open(addr)
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d.Close()
 			dt.Test(t, d, []byte("SELECT 1"))
 		})
 }
@@ -58,18 +66,19 @@ func TestMultiStatement(t *testing.T) {
 	mt.ParallelTest(t, versions, isReady,
 		func(t *testing.T, i mt.Instance) {
 			p := &Postgres{}
-			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
+			addr := pgConnectionString(i.Host(), i.Port())
 			d, err := p.Open(addr)
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d.Close()
 			if err := d.Run(bytes.NewReader([]byte("CREATE TABLE foo (foo text); CREATE TABLE bar (bar text);"))); err != nil {
 				t.Fatalf("expected err to be nil, got %v", err)
 			}
 
 			// make sure second table exists
 			var exists bool
-			if err := d.(*Postgres).db.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bar' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+			if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bar' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
 				t.Fatal(err)
 			}
 			if !exists {
@@ -78,15 +87,37 @@ func TestMultiStatement(t *testing.T) {
 		})
 }
 
+func TestErrorParsing(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Postgres{}
+			addr := pgConnectionString(i.Host(), i.Port())
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			defer d.Close()
+
+			wantErr := `migration failed: syntax error at or near "TABLEE" (column 37) in line 1: CREATE TABLE foo ` +
+				`(foo text); CREATE TABLEE bar (bar text); (details: pq: syntax error at or near "TABLEE")`
+			if err := d.Run(bytes.NewReader([]byte("CREATE TABLE foo (foo text); CREATE TABLEE bar (bar text);"))); err == nil {
+				t.Fatal("expected err but got nil")
+			} else if err.Error() != wantErr {
+				t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+			}
+		})
+}
+
 func TestFilterCustomQuery(t *testing.T) {
 	mt.ParallelTest(t, versions, isReady,
 		func(t *testing.T, i mt.Instance) {
 			p := &Postgres{}
 			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable&x-custom=foobar", i.Host(), i.Port())
-			_, err := p.Open(addr)
+			d, err := p.Open(addr)
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d.Close()
 		})
 }
 
@@ -94,11 +125,12 @@ func TestWithSchema(t *testing.T) {
 	mt.ParallelTest(t, versions, isReady,
 		func(t *testing.T, i mt.Instance) {
 			p := &Postgres{}
-			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
+			addr := pgConnectionString(i.Host(), i.Port())
 			d, err := p.Open(addr)
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d.Close()
 
 			// create foobar schema
 			if err := d.Run(bytes.NewReader([]byte("CREATE SCHEMA foobar AUTHORIZATION postgres"))); err != nil {
@@ -113,6 +145,7 @@ func TestWithSchema(t *testing.T) {
 			if err != nil {
 				t.Fatalf("%v", err)
 			}
+			defer d2.Close()
 
 			version, _, err := d2.Version()
 			if err != nil {
@@ -148,3 +181,120 @@ func TestWithSchema(t *testing.T) {
 func TestWithInstance(t *testing.T) {
 
 }
+
+func TestPostgres_Lock(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Postgres{}
+			addr := pgConnectionString(i.Host(), i.Port())
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+
+			dt.Test(t, d, []byte("SELECT 1"))
+
+			ps := d.(*Postgres)
+
+			err = ps.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = ps.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = ps.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = ps.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+}
+
+func Test_computeLineFromPos(t *testing.T) {
+	testcases := []struct {
+		pos      int
+		wantLine uint
+		wantCol  uint
+		input    string
+		wantOk   bool
+	}{
+		{
+			15, 2, 6, "SELECT *\nFROM foo", true, // foo table does not exists
+		},
+		{
+			16, 3, 6, "SELECT *\n\nFROM foo", true, // foo table does not exists, empty line
+		},
+		{
+			25, 3, 7, "SELECT *\nFROM foo\nWHERE x", true, // x column error
+		},
+		{
+			27, 5, 7, "SELECT *\n\nFROM foo\n\nWHERE x", true, // x column error, empty lines
+		},
+		{
+			10, 2, 1, "SELECT *\nFROMM foo", true, // FROMM typo
+		},
+		{
+			11, 3, 1, "SELECT *\n\nFROMM foo", true, // FROMM typo, empty line
+		},
+		{
+			17, 2, 8, "SELECT *\nFROM foo", true, // last character
+		},
+		{
+			18, 0, 0, "SELECT *\nFROM foo", false, // invalid position
+		},
+	}
+	for i, tc := range testcases {
+		t.Run("tc"+strconv.Itoa(i), func(t *testing.T) {
+			run := func(crlf bool, nonASCII bool) {
+				var name string
+				if crlf {
+					name = "crlf"
+				} else {
+					name = "lf"
+				}
+				if nonASCII {
+					name += "-nonascii"
+				} else {
+					name += "-ascii"
+				}
+				t.Run(name, func(t *testing.T) {
+					input := tc.input
+					if crlf {
+						input = strings.Replace(input, "\n", "\r\n", -1)
+					}
+					if nonASCII {
+						input = strings.Replace(input, "FROM", "FRÖM", -1)
+					}
+					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)
+
+					if tc.wantOk {
+						t.Logf("pos %d, want %d:%d, %#v", tc.pos, tc.wantLine, tc.wantCol, input)
+					}
+
+					if gotOK != tc.wantOk {
+						t.Fatalf("expected ok %v but got %v", tc.wantOk, gotOK)
+					}
+					if gotLine != tc.wantLine {
+						t.Fatalf("expected line %d but got %d", tc.wantLine, gotLine)
+					}
+					if gotCol != tc.wantCol {
+						t.Fatalf("expected col %d but got %d", tc.wantCol, gotCol)
+					}
+				})
+			}
+			run(false, false)
+			run(true, false)
+			run(false, true)
+			run(true, true)
+		})
+	}
+
+}

database/ql/ql.go

@@ -10,8 +10,8 @@ import (
 	nurl "net/url"
 
 	_ "github.com/cznic/ql/driver"
-	"github.com/mattes/migrate"
-	"github.com/mattes/migrate/database"
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
 )
 
 func init() {

database/ql/ql_test.go

@@ -9,9 +9,9 @@ import (
 	"testing"
 
 	_ "github.com/cznic/ql/driver"
-	"github.com/mattes/migrate"
-	dt "github.com/mattes/migrate/database/testing"
-	_ "github.com/mattes/migrate/source/file"
+	"github.com/golang-migrate/migrate"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	_ "github.com/golang-migrate/migrate/source/file"
 )
 
 func Test(t *testing.T) {

database/redshift/redshift.go

@@ -3,8 +3,8 @@ package redshift
 import (
 	"net/url"
 
-	"github.com/mattes/migrate/database"
-	"github.com/mattes/migrate/database/postgres"
+	"github.com/golang-migrate/migrate/database"
+	"github.com/golang-migrate/migrate/database/postgres"
 )
 
 // init registers the driver under the name 'redshift'

database/spanner/README.md

@@ -0,0 +1,35 @@
+# Google Cloud Spanner
+
+## Usage
+
+The DSN must be given in the following format.
+
+`spanner://projects/{projectId}/instances/{instanceId}/databases/{databaseName}`
+
+See [Google Spanner Documentation](https://cloud.google.com/spanner/docs) for details.
+
+
+| Param | WithInstance Config | Description |
+| ----- | ------------------- | ----------- |
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `url` | `DatabaseName` | The full path to the Spanner database resource. If provided as part of `Config` it must not contain a scheme or query string to match the format `projects/{projectId}/instances/{instanceId}/databases/{databaseName}`|
+| `projectId` || The Google Cloud Platform project id
+| `instanceId` || The id of the instance running Spanner
+| `databaseName` || The name of the Spanner database
+
+
+> **Note:** Google Cloud Spanner migrations can take a considerable amount of 
+> time. The migrations provided as part of the example take about 6 minutes to 
+> run on a small instance.
+>
+> ```log
+> 1481574547/u create_users_table (21.354507597s)
+> 1496539702/u add_city_to_users (41.647359754s)
+> 1496601752/u add_index_on_user_emails (2m12.155787369s)
+> 1496602638/u create_books_table (2m30.77299181s)
+
+## Testing
+
+To unit test the `spanner` driver, `SPANNER_DATABASE` needs to be set. You'll
+need to sign-up to Google Cloud Platform (GCP) and have a running Spanner
+instance since it is not possible to run Google Spanner outside GCP.

database/spanner/examples/migrations/1481574547_create_users_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE Users

database/spanner/examples/migrations/1481574547_create_users_table.up.sql

@@ -0,0 +1,5 @@
+CREATE TABLE Users (
+  UserId  INT64,
+  Name    STRING(40),
+  Email   STRING(83)
+) PRIMARY KEY(UserId)

database/spanner/examples/migrations/1496539702_add_city_to_users.down.sql

@@ -0,0 +1 @@
+ALTER TABLE Users DROP COLUMN city

database/spanner/examples/migrations/1496539702_add_city_to_users.up.sql

@@ -0,0 +1 @@
+ALTER TABLE Users ADD COLUMN city STRING(100)

database/spanner/examples/migrations/1496601752_add_index_on_user_emails.down.sql

@@ -0,0 +1 @@
+DROP INDEX UsersEmailIndex

database/spanner/examples/migrations/1496601752_add_index_on_user_emails.up.sql

@@ -0,0 +1 @@
+CREATE UNIQUE INDEX UsersEmailIndex ON Users (Email)

database/spanner/examples/migrations/1496602638_create_books_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE Books

database/spanner/examples/migrations/1496602638_create_books_table.up.sql

@@ -0,0 +1,6 @@
+CREATE TABLE Books (
+  UserId INT64,
+  Name    STRING(40),
+  Author  STRING(40)
+) PRIMARY KEY(UserId, Name), 
+INTERLEAVE IN PARENT Users ON DELETE CASCADE

database/spanner/spanner.go

@@ -0,0 +1,294 @@
+package spanner
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	nurl "net/url"
+	"regexp"
+	"strings"
+
+	"golang.org/x/net/context"
+
+	"cloud.google.com/go/spanner"
+	sdb "cloud.google.com/go/spanner/admin/database/apiv1"
+
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+
+	"google.golang.org/api/iterator"
+	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
+)
+
+func init() {
+	db := Spanner{}
+	database.Register("spanner", &db)
+}
+
+// DefaultMigrationsTable is used if no custom table is specified
+const DefaultMigrationsTable = "SchemaMigrations"
+
+// Driver errors
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+	ErrNoSchema       = fmt.Errorf("no schema")
+	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
+)
+
+// Config used for a Spanner instance
+type Config struct {
+	MigrationsTable string
+	DatabaseName    string
+}
+
+// Spanner implements database.Driver for Google Cloud Spanner
+type Spanner struct {
+	db *DB
+
+	config *Config
+}
+
+type DB struct {
+	admin *sdb.DatabaseAdminClient
+	data  *spanner.Client
+}
+
+// WithInstance implements database.Driver
+func WithInstance(instance *DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if len(config.DatabaseName) == 0 {
+		return nil, ErrNoDatabaseName
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	sx := &Spanner{
+		db:     instance,
+		config: config,
+	}
+
+	if err := sx.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return sx, nil
+}
+
+// Open implements database.Driver
+func (s *Spanner) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := context.Background()
+
+	adminClient, err := sdb.NewDatabaseAdminClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+	dbname := strings.Replace(migrate.FilterCustomQuery(purl).String(), "spanner://", "", 1)
+	dataClient, err := spanner.NewClient(ctx, dbname)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	db := &DB{admin: adminClient, data: dataClient}
+	return WithInstance(db, &Config{
+		DatabaseName:    dbname,
+		MigrationsTable: migrationsTable,
+	})
+}
+
+// Close implements database.Driver
+func (s *Spanner) Close() error {
+	s.db.data.Close()
+	return s.db.admin.Close()
+}
+
+// Lock implements database.Driver but doesn't do anything because Spanner only
+// enqueues the UpdateDatabaseDdlRequest.
+func (s *Spanner) Lock() error {
+	return nil
+}
+
+// Unlock implements database.Driver but no action required, see Lock.
+func (s *Spanner) Unlock() error {
+	return nil
+}
+
+// Run implements database.Driver
+func (s *Spanner) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	// run migration
+	stmts := migrationStatements(migr)
+	ctx := context.Background()
+
+	op, err := s.db.admin.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
+		Database:   s.config.DatabaseName,
+		Statements: stmts,
+	})
+
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	if err := op.Wait(ctx); err != nil {
+		return &database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+// SetVersion implements database.Driver
+func (s *Spanner) SetVersion(version int, dirty bool) error {
+	ctx := context.Background()
+
+	_, err := s.db.data.ReadWriteTransaction(ctx,
+		func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
+			m := []*spanner.Mutation{
+				spanner.Delete(s.config.MigrationsTable, spanner.AllKeys()),
+				spanner.Insert(s.config.MigrationsTable,
+					[]string{"Version", "Dirty"},
+					[]interface{}{version, dirty},
+				)}
+			return txn.BufferWrite(m)
+		})
+	if err != nil {
+		return &database.Error{OrigErr: err}
+	}
+
+	return nil
+}
+
+// Version implements database.Driver
+func (s *Spanner) Version() (version int, dirty bool, err error) {
+	ctx := context.Background()
+
+	stmt := spanner.Statement{
+		SQL: `SELECT Version, Dirty FROM ` + s.config.MigrationsTable + ` LIMIT 1`,
+	}
+	iter := s.db.data.Single().Query(ctx, stmt)
+	defer iter.Stop()
+
+	row, err := iter.Next()
+	switch err {
+	case iterator.Done:
+		return database.NilVersion, false, nil
+	case nil:
+		var v int64
+		if err = row.Columns(&v, &dirty); err != nil {
+			return 0, false, &database.Error{OrigErr: err, Query: []byte(stmt.SQL)}
+		}
+		version = int(v)
+	default:
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(stmt.SQL)}
+	}
+
+	return version, dirty, nil
+}
+
+// Drop implements database.Driver. Retrieves the database schema first and
+// creates statements to drop the indexes and tables accordingly.
+// Note: The drop statements are created in reverse order to how they're
+// provided in the schema. Assuming the schema describes how the database can
+// be "build up", it seems logical to "unbuild" the database simply by going the
+// opposite direction. More testing
+func (s *Spanner) Drop() error {
+	ctx := context.Background()
+	res, err := s.db.admin.GetDatabaseDdl(ctx, &adminpb.GetDatabaseDdlRequest{
+		Database: s.config.DatabaseName,
+	})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "drop failed"}
+	}
+	if len(res.Statements) == 0 {
+		return nil
+	}
+
+	r := regexp.MustCompile(`(CREATE TABLE\s(\S+)\s)|(CREATE.+INDEX\s(\S+)\s)`)
+	stmts := make([]string, 0)
+	for i := len(res.Statements) - 1; i >= 0; i-- {
+		s := res.Statements[i]
+		m := r.FindSubmatch([]byte(s))
+
+		if len(m) == 0 {
+			continue
+		} else if tbl := m[2]; len(tbl) > 0 {
+			stmts = append(stmts, fmt.Sprintf(`DROP TABLE %s`, tbl))
+		} else if idx := m[4]; len(idx) > 0 {
+			stmts = append(stmts, fmt.Sprintf(`DROP INDEX %s`, idx))
+		}
+	}
+
+	op, err := s.db.admin.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
+		Database:   s.config.DatabaseName,
+		Statements: stmts,
+	})
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(strings.Join(stmts, "; "))}
+	}
+	if err := op.Wait(ctx); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(strings.Join(stmts, "; "))}
+	}
+
+	if err := s.ensureVersionTable(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Spanner) ensureVersionTable() error {
+	ctx := context.Background()
+	tbl := s.config.MigrationsTable
+	iter := s.db.data.Single().Read(ctx, tbl, spanner.AllKeys(), []string{"Version"})
+	if err := iter.Do(func(r *spanner.Row) error { return nil }); err == nil {
+		return nil
+	}
+
+	stmt := fmt.Sprintf(`CREATE TABLE %s (
+    Version INT64 NOT NULL,
+    Dirty    BOOL NOT NULL
+	) PRIMARY KEY(Version)`, tbl)
+
+	op, err := s.db.admin.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
+		Database:   s.config.DatabaseName,
+		Statements: []string{stmt},
+	})
+
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(stmt)}
+	}
+	if err := op.Wait(ctx); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(stmt)}
+	}
+
+	return nil
+}
+
+func migrationStatements(migration []byte) []string {
+	regex := regexp.MustCompile(";$")
+	migrationString := string(migration[:])
+	migrationString = strings.TrimSpace(migrationString)
+	migrationString = regex.ReplaceAllString(migrationString, "")
+
+	statements := strings.Split(migrationString, ";")
+	return statements
+}

database/spanner/spanner_test.go

@@ -0,0 +1,28 @@
+package spanner
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	dt "github.com/golang-migrate/migrate/database/testing"
+)
+
+func Test(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+
+	db, ok := os.LookupEnv("SPANNER_DATABASE")
+	if !ok {
+		t.Skip("SPANNER_DATABASE not set, skipping test.")
+	}
+
+	s := &Spanner{}
+	addr := fmt.Sprintf("spanner://%v", db)
+	d, err := s.Open(addr)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	dt.Test(t, d, []byte("SELECT 1"))
+}

database/sqlite3/migration/33_create_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;

database/sqlite3/migration/33_create_table.up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE pets (
+  name string
+);

database/sqlite3/migration/44_alter_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;

database/sqlite3/migration/44_alter_table.up.sql

@@ -0,0 +1 @@
+ALTER TABLE pets ADD predator bool;

database/sqlite3/sqlite3.go

@@ -0,0 +1,214 @@
+package sqlite3
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/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
+}

database/sqlite3/sqlite3_test.go

@@ -0,0 +1,61 @@
+package sqlite3
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/golang-migrate/migrate"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	_ "github.com/golang-migrate/migrate/source/file"
+	_ "github.com/mattn/go-sqlite3"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	dir, err := ioutil.TempDir("", "sqlite3-driver-test")
+	if err != nil {
+		return
+	}
+	defer func() {
+		os.RemoveAll(dir)
+	}()
+	fmt.Printf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))
+	p := &Sqlite{}
+	addr := fmt.Sprintf("sqlite3://%s", filepath.Join(dir, "sqlite3.db"))
+	d, err := p.Open(addr)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+
+	db, err := sql.Open("sqlite3", filepath.Join(dir, "sqlite3.db"))
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			return
+		}
+	}()
+	dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);"))
+	driver, err := WithInstance(db, &Config{})
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if err := d.Drop(); err != nil {
+		t.Fatal(err)
+	}
+
+	m, err := migrate.NewWithDatabaseInstance(
+		"file://./migration",
+		"ql", driver)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	fmt.Println("UP")
+	err = m.Up()
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+}

database/stub/stub.go

@@ -5,7 +5,7 @@ import (
 	"io/ioutil"
 	"reflect"
 
-	"github.com/mattes/migrate/database"
+	"github.com/golang-migrate/migrate/database"
 )
 
 func init() {

database/stub/stub_test.go

@@ -3,7 +3,7 @@ package stub
 import (
 	"testing"
 
-	dt "github.com/mattes/migrate/database/testing"
+	dt "github.com/golang-migrate/migrate/database/testing"
 )
 
 func Test(t *testing.T) {

database/testing/testing.go

@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/mattes/migrate/database"
+	"github.com/golang-migrate/migrate/database"
 )
 
 // Test runs tests against database implementations.

database/util.go

@@ -7,7 +7,7 @@ import (
 
 const advisoryLockIdSalt uint = 1486364155
 
-// inspired by rails migrations, see https://goo.gl/8o9bCT
+// GenerateAdvisoryLockId inspired by rails migrations, see https://goo.gl/8o9bCT
 func GenerateAdvisoryLockId(databaseName string) (string, error) {
 	sum := crc32.ChecksumIEEE([]byte(databaseName))
 	sum = sum * uint32(advisoryLockIdSalt)

database/util_test.go

@@ -1,12 +1,28 @@
 package database
 
+import (
+	"testing"
+)
+
 func TestGenerateAdvisoryLockId(t *testing.T) {
-	id, err := p.generateAdvisoryLockId("database_name")
-	if err != nil {
-		t.Errorf("expected err to be nil, got %v", err)
+	testcases := []struct {
+		dbname     string
+		expectedID string // empty string signifies that an error is expected
+	}{
+		{dbname: "database_name", expectedID: "1764327054"},
 	}
-	if len(id) == 0 {
-		t.Errorf("expected generated id not to be empty")
+
+	for _, tc := range testcases {
+		t.Run(tc.dbname, func(t *testing.T) {
+			if id, err := GenerateAdvisoryLockId("database_name"); err == nil {
+				if id != tc.expectedID {
+					t.Error("Generated incorrect ID:", id, "!=", tc.expectedID)
+				}
+			} else {
+				if tc.expectedID != "" {
+					t.Error("Got unexpected error:", err)
+				}
+			}
+		})
 	}
-	t.Logf("generated id: %v", id)
 }

docker-deploy.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin && \
+docker build --build-arg VERSION="$TRAVIS_TAG" . -t migrate/migrate -t migrate/migrate:"$TRAVIS_TAG" && \
+docker push migrate/migrate:"$TRAVIS_TAG" && docker push migrate/migrate

go.mod

@@ -0,0 +1,75 @@
+module github.com/golang-migrate/migrate
+
+require (
+	cloud.google.com/go v0.23.0
+	github.com/Microsoft/go-winio v0.4.9 // indirect
+	github.com/Sirupsen/logrus v1.0.6 // indirect
+	github.com/aws/aws-sdk-go v1.14.32
+	github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 // indirect
+	github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect
+	github.com/cockroachdb/cockroach-go v0.0.0-20180212155653-59c0560478b7
+	github.com/cznic/b v0.0.0-20180115125044-35e9bbe41f07 // indirect
+	github.com/cznic/fileutil v0.0.0-20180108211300-6a051e75936f // indirect
+	github.com/cznic/internal v0.0.0-20160905094039-cef02a853c3a // indirect
+	github.com/cznic/lldb v1.1.0 // indirect
+	github.com/cznic/mathutil v0.0.0-20180504122225-ca4c9f2c1369 // indirect
+	github.com/cznic/ql v1.1.0
+	github.com/cznic/sortutil v0.0.0-20150617083342-4c7342852e65 // indirect
+	github.com/cznic/strutil v0.0.0-20171016134553-529a34b1c186 // indirect
+	github.com/cznic/zappy v0.0.0-20160723133515-2533cb5b45cc // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/docker/distribution v0.0.0-20180720172123-0dae0957e5fe // indirect
+	github.com/docker/docker v0.0.0-20170502054910-90d35abf7b35
+	github.com/docker/go-connections v0.3.0 // indirect
+	github.com/docker/go-units v0.3.3 // indirect
+	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
+	github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 // indirect
+	github.com/fsnotify/fsnotify v1.4.7 // indirect
+	github.com/fsouza/fake-gcs-server v1.0.0
+	github.com/go-ini/ini v1.38.1 // indirect
+	github.com/go-sql-driver/mysql v1.4.0
+	github.com/gocql/gocql v0.0.0-20180617115710-e06f8c1bcd78
+	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
+	github.com/golang/protobuf v1.1.0 // indirect
+	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
+	github.com/google/go-cmp v0.2.0 // indirect
+	github.com/google/go-github v15.0.0+incompatible
+	github.com/google/go-querystring v0.0.0-20170111101155-53e6ce116135 // indirect
+	github.com/googleapis/gax-go v2.0.0+incompatible // indirect
+	github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c // indirect
+	github.com/gorilla/context v1.1.1 // indirect
+	github.com/gorilla/mux v1.6.2 // indirect
+	github.com/hpcloud/tail v1.0.0 // indirect
+	github.com/jtolds/gls v4.2.1+incompatible // indirect
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/kshvakov/clickhouse v1.3.3
+	github.com/lib/pq v0.0.0-20180523175426-90697d60dd84
+	github.com/mattn/go-sqlite3 v1.9.0
+	github.com/onsi/ginkgo v1.6.0 // indirect
+	github.com/onsi/gomega v1.4.1 // indirect
+	github.com/opencontainers/go-digest v1.0.0-rc1 // indirect
+	github.com/pkg/errors v0.8.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/sirupsen/logrus v1.0.6 // indirect
+	github.com/smartystreets/assertions v0.0.0-20180820201707-7c9eb446e3cf // indirect
+	github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a // indirect
+	github.com/stretchr/testify v1.2.2 // indirect
+	go.opencensus.io v0.14.0 // indirect
+	golang.org/x/crypto v0.0.0-20180723164146-c126467f60eb // indirect
+	golang.org/x/net v0.0.0-20180724234803-3673e40ba225
+	golang.org/x/oauth2 v0.0.0-20180724155351-3d292e4d0cdc // indirect
+	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f // indirect
+	golang.org/x/sys v0.0.0-20180724212812-e072cadbbdc8 // indirect
+	golang.org/x/text v0.3.0 // indirect
+	golang.org/x/tools v0.0.0-20180725002046-526516e9c4bf
+	google.golang.org/api v0.0.0-20180724000608-2c45710c7f3f
+	google.golang.org/appengine v1.1.0 // indirect
+	google.golang.org/genproto v0.0.0-20180722052100-02b4e9547331
+	google.golang.org/grpc v1.13.0 // indirect
+	gopkg.in/airbrake/gobrake.v2 v2.0.9 // indirect
+	gopkg.in/fsnotify.v1 v1.4.7 // indirect
+	gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 // indirect
+	gopkg.in/ini.v1 v1.38.2 // indirect
+	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
+	gopkg.in/yaml.v2 v2.2.1 // indirect
+)

go.sum

@@ -0,0 +1,155 @@
+cloud.google.com/go v0.23.0 h1:w1svupRqvZnfjN9+KksMiggoIRQuMzWkVzpxcR96xDs=
+cloud.google.com/go v0.23.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/Microsoft/go-winio v0.4.9 h1:3RbgqgGVqmcpbOiwrjbVtDHLlJBGF6aE+yHmNtBNsFQ=
+github.com/Microsoft/go-winio v0.4.9/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA=
+github.com/Sirupsen/logrus v1.0.6 h1:HCAGQRk48dRVPA5Y+Yh0qdCSTzPOyU1tBJ7Q9YzotII=
+github.com/Sirupsen/logrus v1.0.6/go.mod h1:rmk17hk6i8ZSAJkSDa7nOxamrG+SP4P0mm+DAvExv4U=
+github.com/aws/aws-sdk-go v1.14.32 h1:0Y2CFPSWlvQfGzQ8eZgZqg/NZ9yE5whI382l/bm+Tqw=
+github.com/aws/aws-sdk-go v1.14.32/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
+github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY=
+github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k=
+github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
+github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
+github.com/cockroachdb/cockroach-go v0.0.0-20180212155653-59c0560478b7 h1:XFqp7VFIbbJO1hlpGbzo45NVYWVIM2eMD9MAxrOTVzU=
+github.com/cockroachdb/cockroach-go v0.0.0-20180212155653-59c0560478b7/go.mod h1:XGLbWH/ujMcbPbhZq52Nv6UrCghb1yGn//133kEsvDk=
+github.com/cznic/b v0.0.0-20180115125044-35e9bbe41f07 h1:UHFGPvSxX4C4YBApSPvmUfL8tTvWLj2ryqvT9K4Jcuk=
+github.com/cznic/b v0.0.0-20180115125044-35e9bbe41f07/go.mod h1:URriBxXwVq5ijiJ12C7iIZqlA69nTlI+LgI6/pwftG8=
+github.com/cznic/fileutil v0.0.0-20180108211300-6a051e75936f h1:7uSNgsgcarNk4oiN/nNkO0J7KAjlsF5Yv5Gf/tFdHas=
+github.com/cznic/fileutil v0.0.0-20180108211300-6a051e75936f/go.mod h1:8S58EK26zhXSxzv7NQFpnliaOQsmDUxvoQO3rt154Vg=
+github.com/cznic/internal v0.0.0-20160905094039-cef02a853c3a h1:EolazeOl7b7TLyKH66MzefRUB27hxJAfnrGcaKmJKVE=
+github.com/cznic/internal v0.0.0-20160905094039-cef02a853c3a/go.mod h1:olo7eAdKwJdXxb55TKGLiJ6xt1H0/tiiRCWKVLmtjY4=
+github.com/cznic/lldb v1.1.0 h1:AIA+ham6TSJ+XkMe8imQ/g8KPzMUVWAwqUQQdtuMsHs=
+github.com/cznic/lldb v1.1.0/go.mod h1:FIZVUmYUVhPwRiPzL8nD/mpFcJ/G7SSXjjXYG4uRI3A=
+github.com/cznic/mathutil v0.0.0-20180504122225-ca4c9f2c1369 h1:XNT/Zf5l++1Pyg08/HV04ppB0gKxAqtZQBRYiYrUuYk=
+github.com/cznic/mathutil v0.0.0-20180504122225-ca4c9f2c1369/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM=
+github.com/cznic/ql v1.1.0 h1:/ByVHV7ADDnAVCNzYvJGBnCYF+YR16qGPX4Q+tBRK4c=
+github.com/cznic/ql v1.1.0/go.mod h1:YhViR8X3dW5uRADlFXxbh3suMUVYoCeAdyhweCWukWk=
+github.com/cznic/sortutil v0.0.0-20150617083342-4c7342852e65 h1:hxuZop6tSoOi0sxFzoGGYdRqNrPubyaIf9KoBG9tPiE=
+github.com/cznic/sortutil v0.0.0-20150617083342-4c7342852e65/go.mod h1:q2w6Bg5jeox1B+QkJ6Wp/+Vn0G/bo3f1uY7Fn3vivIQ=
+github.com/cznic/strutil v0.0.0-20171016134553-529a34b1c186 h1:0rkFMAbn5KBKNpJyHQ6Prb95vIKanmAe62KxsrN+sqA=
+github.com/cznic/strutil v0.0.0-20171016134553-529a34b1c186/go.mod h1:AHHPPPXTw0h6pVabbcbyGRK1DckRn7r/STdZEeIDzZc=
+github.com/cznic/zappy v0.0.0-20160723133515-2533cb5b45cc h1:YKKpTb2BrXN2GYyGaygIdis1vXbE7SSAG9axGWIMClg=
+github.com/cznic/zappy v0.0.0-20160723133515-2533cb5b45cc/go.mod h1:Y1SNZ4dRUOKXshKUbwUapqNncRrho4mkjQebgEHZLj8=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/docker/distribution v0.0.0-20180720172123-0dae0957e5fe h1:ZRQNMB7Sw5jf9g/0imDbI+vTFNk4J7qBdtFI5/zf1kg=
+github.com/docker/distribution v0.0.0-20180720172123-0dae0957e5fe/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
+github.com/docker/docker v0.0.0-20170502054910-90d35abf7b35 h1:zQuy/ry/KtSvCczhEPo+ud47S8alruA/Z9NDlz7EzVo=
+github.com/docker/docker v0.0.0-20170502054910-90d35abf7b35/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.3.0 h1:3lOnM9cSzgGwx8VfK/NGOW5fLQ0GjIlCkaktF+n1M6o=
+github.com/docker/go-connections v0.3.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
+github.com/docker/go-units v0.3.3 h1:Xk8S3Xj5sLGlG5g67hJmYMmUgXv5N4PhkjJHHqrwnTk=
+github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4=
+github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE=
+github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
+github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsouza/fake-gcs-server v1.0.0 h1:7kcQ/UdgSRt+gmkJZZIbJpkafcuQHnuspE/CFA36+cM=
+github.com/fsouza/fake-gcs-server v1.0.0/go.mod h1:1/HufuJ+eaDf4KTnYdS6HJMGvMRU8d4cYTuu/1QaBbI=
+github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/go-ini/ini v1.38.1 h1:hbtfM8emWUVo9GnXSloXYyFbXxZ+tG6sbepSStoe1FY=
+github.com/go-ini/ini v1.38.1/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/go-sql-driver/mysql v1.4.0 h1:7LxgVwFb2hIQtMm87NdgAVfXjnt4OePseqT1tKx+opk=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/gocql/gocql v0.0.0-20180617115710-e06f8c1bcd78 h1:G7iRamCffNivybfZvsJjtk3k2qHa73xW+OysVkukcGk=
+github.com/gocql/gocql v0.0.0-20180617115710-e06f8c1bcd78/go.mod h1:4Fw1eo5iaEhDUs8XyuhSVCVy52Jq3L+/3GJgYkwc+/0=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/protobuf v1.1.0 h1:0iH4Ffd/meGoXqF2lSAhZHt8X+cPgkfn/cb6Cce5Vpc=
+github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-github v15.0.0+incompatible h1:jlPg2Cpsxb/FyEV/MFiIE9tW/2RAevQNZDPeHbf5a94=
+github.com/google/go-github v15.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v0.0.0-20170111101155-53e6ce116135 h1:zLTLjkaOFEFIOxY5BWLFLwh+cL8vOBW4XJ2aqLE/Tf0=
+github.com/google/go-querystring v0.0.0-20170111101155-53e6ce116135/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/googleapis/gax-go v2.0.0+incompatible h1:j0GKcs05QVmm7yesiZq2+9cxHkNK9YM6zKx4D2qucQU=
+github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
+github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c h1:16eHWuMGvCjSfgRJKqIzapE78onvvTbdi1rMkU00lZw=
+github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1 h1:AWwleXJkX/nhcU9bZSnZoi3h/qGYqQAGhq6zZe/aQW8=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/mux v1.6.2 h1:Pgr17XVTNXAk3q/r4CpKzC5xBM/qW1uVLV+IhRZpIIk=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
+github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jtolds/gls v4.2.1+incompatible h1:fSuqC+Gmlu6l/ZYAoZzx2pyucC8Xza35fpRVWLVmUEE=
+github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kshvakov/clickhouse v1.3.3 h1:oT3ktCQcfr9bJz/Wftm0nSJtfYWwlf4YwHVxgBWa8Dg=
+github.com/kshvakov/clickhouse v1.3.3/go.mod h1:DMzX7FxRymoNkVgizH0DWAL8Cur7wHLgx3MUnGwJqpE=
+github.com/lib/pq v0.0.0-20180523175426-90697d60dd84 h1:it29sI2IM490luSc3RAhp5WuCYnc6RtbfLVAB7nmC5M=
+github.com/lib/pq v0.0.0-20180523175426-90697d60dd84/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mattn/go-sqlite3 v1.9.0 h1:pDRiWfl+++eC2FEFRy6jXmQlvp4Yh3z1MJKg4UeYM/4=
+github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.1 h1:PZSj/UFNaVp3KxrzHOcS7oyuWA7LoOY/77yCTEFu21U=
+github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/opencontainers/go-digest v1.0.0-rc1 h1:WzifXhOVOEOuFYOJAW6aQqW0TooG2iki3E3Ii+WN7gQ=
+github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.0.6 h1:hcP1GmhGigz/O7h1WVUM5KklBp1JoNS9FggWKdj/j3s=
+github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
+github.com/smartystreets/assertions v0.0.0-20180820201707-7c9eb446e3cf h1:6V1qxN6Usn4jy8unvggSJz/NC790tefw8Zdy6OZS5co=
+github.com/smartystreets/assertions v0.0.0-20180820201707-7c9eb446e3cf/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a h1:JSvGDIbmil4Ui/dDdFBExb7/cmkNjyX5F97oglmvCDo=
+github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+go.opencensus.io v0.14.0 h1:1eTLxqxSIAylcKoxnNkdhvvBNZDA8JwkKNXxgyma0IA=
+go.opencensus.io v0.14.0/go.mod h1:UffZAU+4sDEINUGP/B7UfBBkq4fqLu9zXAX7ke6CHW0=
+golang.org/x/crypto v0.0.0-20180723164146-c126467f60eb h1:Ah9YqXLj6fEgeKqcmBuLCbAsrF3ScD7dJ/bYM0C6tXI=
+golang.org/x/crypto v0.0.0-20180723164146-c126467f60eb/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225 h1:kNX+jCowfMYzvlSvJu5pQWEmyWFrBXJ3PBy10xKMXK8=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20180724155351-3d292e4d0cdc h1:3ElrZeO6IBP+M8kgu5YFwRo92Gqr+zBg3aooYQ6ziqU=
+golang.org/x/oauth2 v0.0.0-20180724155351-3d292e4d0cdc/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180724212812-e072cadbbdc8 h1:7T3bTJEttnfJdEY+NY/VYT7IXRaul8potWiyw/n7LB8=
+golang.org/x/sys v0.0.0-20180724212812-e072cadbbdc8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20180725002046-526516e9c4bf h1:La9VHshxVvEPYzT2+6+JjrMwJ8S5DHz20oPvh3DLn4I=
+golang.org/x/tools v0.0.0-20180725002046-526516e9c4bf/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/api v0.0.0-20180724000608-2c45710c7f3f h1:uiKtoTrsrUiX2ErhGoP5/QUlz1Z4sJix0GzrLz6y01M=
+google.golang.org/api v0.0.0-20180724000608-2c45710c7f3f/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180722052100-02b4e9547331 h1:IMH1YerpV21AUtlZhkKVDH2YQ4vo/qzMPHpECOIew/0=
+google.golang.org/genproto v0.0.0-20180722052100-02b4e9547331/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/grpc v1.13.0 h1:bHIbVsCwmvbArgCJmLdgOdHFXlKqTOVjbibbS19cXHc=
+google.golang.org/grpc v1.13.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+gopkg.in/airbrake/gobrake.v2 v2.0.9 h1:7z2uVWwn7oVeeugY1DtlPAy5H+KYgB1KeKTnqjNatLo=
+gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 h1:OAj3g0cR6Dx/R07QgQe8wkA9RNjB2u4i700xBkIT4e0=
+gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/ini.v1 v1.38.2 h1:dGcbywv4RufeGeiMycPT/plKB5FtmLKLnWKwBiLhUA4=
+gopkg.in/ini.v1 v1.38.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

migrate.go

@@ -10,8 +10,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/mattes/migrate/database"
-	"github.com/mattes/migrate/source"
+	"github.com/golang-migrate/migrate/database"
+	"github.com/golang-migrate/migrate/source"
 )
 
 // DefaultPrefetchMigrations sets the number of migrations to pre-read
@@ -61,7 +61,7 @@ type Migrate struct {
 
 	// GracefulStop accepts `true` and will stop executing migrations
 	// as soon as possible at a safe break point, so that the database
-	// is not corrpupted.
+	// is not corrupted.
 	GracefulStop   chan bool
 	isGracefulStop bool
 
@@ -82,13 +82,13 @@ type Migrate struct {
 func New(sourceUrl, databaseUrl string) (*Migrate, error) {
 	m := newCommon()
 
-	sourceName, err := schemeFromUrl(sourceUrl)
+	sourceName, err := sourceSchemeFromUrl(sourceUrl)
 	if err != nil {
 		return nil, err
 	}
 	m.sourceName = sourceName
 
-	databaseName, err := schemeFromUrl(databaseUrl)
+	databaseName, err := databaseSchemeFromUrl(databaseUrl)
 	if err != nil {
 		return nil, err
 	}
@@ -300,7 +300,7 @@ func (m *Migrate) Down() error {
 	return m.unlockErr(m.runMigrations(ret))
 }
 
-// Drop deletes everyting in the database.
+// Drop deletes everything in the database.
 func (m *Migrate) Drop() error {
 	if err := m.lock(); err != nil {
 		return err
@@ -395,16 +395,16 @@ func (m *Migrate) read(from int, to int, ret chan<- interface{}) {
 
 	// check if from version exists
 	if from >= 0 {
-		if m.versionExists(suint(from)) != nil {
-			ret <- os.ErrNotExist
+		if err := m.versionExists(suint(from)); err != nil {
+			ret <- err
 			return
 		}
 	}
 
 	// check if to version exists
 	if to >= 0 {
-		if m.versionExists(suint(to)) != nil {
-			ret <- os.ErrNotExist
+		if err := m.versionExists(suint(to)); err != nil {
+			ret <- err
 			return
 		}
 	}
@@ -507,8 +507,8 @@ func (m *Migrate) readUp(from int, limit int, ret chan<- interface{}) {
 
 	// check if from version exists
 	if from >= 0 {
-		if m.versionExists(suint(from)) != nil {
-			ret <- os.ErrNotExist
+		if err := m.versionExists(suint(from)); err != nil {
+			ret <- err
 			return
 		}
 	}
@@ -599,8 +599,8 @@ func (m *Migrate) readDown(from int, limit int, ret chan<- interface{}) {
 
 	// check if from version exists
 	if from >= 0 {
-		if m.versionExists(suint(from)) != nil {
-			ret <- os.ErrNotExist
+		if err := m.versionExists(suint(from)); err != nil {
+			ret <- err
 			return
 		}
 	}

migrate_test.go

@@ -8,9 +8,9 @@ import (
 	"os"
 	"testing"
 
-	dStub "github.com/mattes/migrate/database/stub"
-	"github.com/mattes/migrate/source"
-	sStub "github.com/mattes/migrate/source/stub"
+	dStub "github.com/golang-migrate/migrate/database/stub"
+	"github.com/golang-migrate/migrate/source"
+	sStub "github.com/golang-migrate/migrate/source/stub"
 )
 
 // sourceStubMigrations hold the following migrations:
@@ -21,14 +21,14 @@ var sourceStubMigrations *source.Migrations
 
 func init() {
 	sourceStubMigrations = source.NewMigrations()
-	sourceStubMigrations.Append(&source.Migration{Version: 1, Direction: source.Up})
-	sourceStubMigrations.Append(&source.Migration{Version: 1, Direction: source.Down})
-	sourceStubMigrations.Append(&source.Migration{Version: 3, Direction: source.Up})
-	sourceStubMigrations.Append(&source.Migration{Version: 4, Direction: source.Up})
-	sourceStubMigrations.Append(&source.Migration{Version: 4, Direction: source.Down})
-	sourceStubMigrations.Append(&source.Migration{Version: 5, Direction: source.Down})
-	sourceStubMigrations.Append(&source.Migration{Version: 7, Direction: source.Up})
-	sourceStubMigrations.Append(&source.Migration{Version: 7, Direction: source.Down})
+	sourceStubMigrations.Append(&source.Migration{Version: 1, Direction: source.Up, Identifier: "CREATE 1"})
+	sourceStubMigrations.Append(&source.Migration{Version: 1, Direction: source.Down, Identifier: "DROP 1"})
+	sourceStubMigrations.Append(&source.Migration{Version: 3, Direction: source.Up, Identifier: "CREATE 3"})
+	sourceStubMigrations.Append(&source.Migration{Version: 4, Direction: source.Up, Identifier: "CREATE 4"})
+	sourceStubMigrations.Append(&source.Migration{Version: 4, Direction: source.Down, Identifier: "DROP 4"})
+	sourceStubMigrations.Append(&source.Migration{Version: 5, Direction: source.Down, Identifier: "DROP 5"})
+	sourceStubMigrations.Append(&source.Migration{Version: 7, Direction: source.Up, Identifier: "CREATE 7"})
+	sourceStubMigrations.Append(&source.Migration{Version: 7, Direction: source.Down, Identifier: "DROP 7"})
 }
 
 type DummyInstance struct{ Name string }
@@ -104,7 +104,7 @@ func ExampleNewWithDatabaseInstance() {
 
 	// Create driver instance from db.
 	// Check each driver if it supports the WithInstance function.
-	// `import "github.com/mattes/migrate/database/postgres"`
+	// `import "github.com/golang-migrate/migrate/database/postgres"`
 	instance, err := dStub.WithInstance(db, &dStub.Config{})
 	if err != nil {
 		log.Fatal(err)
@@ -154,7 +154,7 @@ func ExampleNewWithSourceInstance() {
 
 	// Create driver instance from DummyInstance di.
 	// Check each driver if it support the WithInstance function.
-	// `import "github.com/mattes/migrate/source/stub"`
+	// `import "github.com/golang-migrate/migrate/source/stub"`
 	instance, err := sStub.WithInstance(di, &sStub.Config{})
 	if err != nil {
 		log.Fatal(err)
@@ -224,7 +224,6 @@ func TestMigrate(t *testing.T) {
 	m, _ := New("stub://", "stub://")
 	m.sourceDrv.(*sStub.Stub).Migrations = sourceStubMigrations
 	dbDrv := m.databaseDrv.(*dStub.Stub)
-	seq := newMigSeq()
 
 	tt := []struct {
 		version       uint
@@ -233,33 +232,226 @@ func TestMigrate(t *testing.T) {
 		expectSeq     migrationSequence
 	}{
 		// migrate all the way Up in single steps
-		{version: 0, expectErr: os.ErrNotExist},
-		{version: 1, expectErr: nil, expectVersion: 1, expectSeq: seq.add(M(1))},
-		{version: 2, expectErr: os.ErrNotExist},
-		{version: 3, expectErr: nil, expectVersion: 3, expectSeq: seq.add(M(3))},
-		{version: 4, expectErr: nil, expectVersion: 4, expectSeq: seq.add(M(4))},
-		{version: 5, expectErr: nil, expectVersion: 5, expectSeq: seq.add()}, // 5 has no up migration
-		{version: 6, expectErr: os.ErrNotExist},
-		{version: 7, expectErr: nil, expectVersion: 7, expectSeq: seq.add(M(7))},
-		{version: 8, expectErr: os.ErrNotExist},
+		{
+			version:   0,
+			expectErr: os.ErrNotExist,
+		},
+		{
+			version:       1,
+			expectVersion: 1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+			},
+		},
+		{
+			version:   2,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+			},
+		},
+		{
+			version:       3,
+			expectVersion: 3,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+			},
+		},
+		{
+			version:       4,
+			expectVersion: 4,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
+		{
+			version:       5,
+			expectVersion: 5,
+			expectSeq: migrationSequence{ // 5 has no up migration
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
+		{
+			version:   6,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
+		{
+			version:       7,
+			expectVersion: 7,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
+		{
+			version:   8,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
 
 		// migrate all the way Down in single steps
-		{version: 6, expectErr: os.ErrNotExist},
-		{version: 5, expectErr: nil, expectVersion: 5, expectSeq: seq.add(M(7, 5))},
-		{version: 4, expectErr: nil, expectVersion: 4, expectSeq: seq.add(M(5, 4))},
-		{version: 3, expectErr: nil, expectVersion: 3, expectSeq: seq.add(M(4, 3))},
-		{version: 2, expectErr: os.ErrNotExist},
-		{version: 1, expectErr: nil, expectVersion: 1, expectSeq: seq.add()}, // 3 has no down migration
-		{version: 0, expectErr: os.ErrNotExist},
+		{
+			version:   6,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
+		{
+			version:       5,
+			expectVersion: 5,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+			},
+		},
+		{
+			version:       4,
+			expectVersion: 4,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+			},
+		},
+		{
+			version:       3,
+			expectVersion: 3,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
+		{
+			version:   2,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
+		{
+			version:       1,
+			expectVersion: 1,
+			expectSeq: migrationSequence{ // 3 has no down migration
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
+		{
+			version:   0,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
 
 		// migrate all the way Up in one step
-		{version: 7, expectErr: nil, expectVersion: 7, expectSeq: seq.add(M(3), M(4), M(7))},
+		{
+			version:       7,
+			expectVersion: 7,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
 
 		// migrate all the way Down in one step
-		{version: 1, expectErr: nil, expectVersion: 1, expectSeq: seq.add(M(7, 5), M(5, 4), M(4, 3), M(3, 1))},
+		{
+			version:       1,
+			expectVersion: 1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
 
 		// can't migrate the same version twice
-		{version: 1, expectErr: ErrNoChange},
+		{
+			version:   1,
+			expectErr: ErrNoChange,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
 	}
 
 	for i, v := range tt {
@@ -276,8 +468,8 @@ func TestMigrate(t *testing.T) {
 			if version != v.expectVersion {
 				t.Errorf("expected version %v, got %v, in %v", v.expectVersion, version, i)
 			}
-			equalDbSeq(t, i, v.expectSeq, dbDrv)
 		}
+		equalDbSeq(t, i, v.expectSeq, dbDrv)
 	}
 }
 
@@ -298,50 +490,235 @@ func TestSteps(t *testing.T) {
 	m, _ := New("stub://", "stub://")
 	m.sourceDrv.(*sStub.Stub).Migrations = sourceStubMigrations
 	dbDrv := m.databaseDrv.(*dStub.Stub)
-	seq := newMigSeq()
 
 	tt := []struct {
-		n             int
+		steps         int
 		expectErr     error
 		expectVersion int
 		expectSeq     migrationSequence
 	}{
 		// step must be != 0
-		{n: 0, expectErr: ErrNoChange},
+		{
+			steps:     0,
+			expectErr: ErrNoChange,
+		},
 
 		// can't go Down if ErrNilVersion
-		{n: -1, expectErr: os.ErrNotExist},
+		{
+			steps:     -1,
+			expectErr: os.ErrNotExist,
+		},
 
 		// migrate all the way Up
-		{n: 1, expectErr: nil, expectVersion: 1, expectSeq: seq.add(M(1))},
-		{n: 1, expectErr: nil, expectVersion: 3, expectSeq: seq.add(M(3))},
-		{n: 1, expectErr: nil, expectVersion: 4, expectSeq: seq.add(M(4))},
-		{n: 1, expectErr: nil, expectVersion: 5, expectSeq: seq.add()},
-		{n: 1, expectErr: nil, expectVersion: 7, expectSeq: seq.add(M(7))},
-		{n: 1, expectErr: os.ErrNotExist},
+		{
+			steps:         1,
+			expectVersion: 1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1")},
+		},
+		{
+			steps:         1,
+			expectVersion: 3,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+			},
+		},
+		{
+			steps:         1,
+			expectVersion: 4,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
+		{
+			steps:         1,
+			expectVersion: 5,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
+		{
+			steps:         1,
+			expectVersion: 7,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
+		{
+			steps:     1,
+			expectErr: os.ErrNotExist,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
 
 		// migrate all the way Down
-		{n: -1, expectErr: nil, expectVersion: 5, expectSeq: seq.add(M(7, 5))},
-		{n: -1, expectErr: nil, expectVersion: 4, expectSeq: seq.add(M(5, 4))},
-		{n: -1, expectErr: nil, expectVersion: 3, expectSeq: seq.add(M(4, 3))},
-		{n: -1, expectErr: nil, expectVersion: 1, expectSeq: seq.add(M(3, 1))},
-		{n: -1, expectErr: nil, expectVersion: -1, expectSeq: seq.add(M(1, -1))},
+		{
+			steps:         -1,
+			expectVersion: 5,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+			},
+		},
+		{
+			steps:         -1,
+			expectVersion: 4,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+			},
+		},
+		{
+			steps:         -1,
+			expectVersion: 3,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
+		{
+			steps:         -1,
+			expectVersion: 1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
+		{
+			steps:         -1,
+			expectVersion: -1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+			},
+		},
 
 		// migrate Up in bigger step
-		{n: 4, expectErr: nil, expectVersion: 5, expectSeq: seq.add(M(1), M(3), M(4), M(5))},
+		{
+			steps:         4,
+			expectVersion: 5,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+			},
+		},
 
 		// apply one migration, then reaches out of boundary
-		{n: 2, expectErr: ErrShortLimit{1}, expectVersion: 7, expectSeq: seq.add(M(7))},
+		{
+			steps:         2,
+			expectErr:     ErrShortLimit{1},
+			expectVersion: 7,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+			},
+		},
 
 		// migrate Down in bigger step
-		{n: -4, expectErr: nil, expectVersion: 1, expectSeq: seq.add(M(7, 5), M(5, 4), M(4, 3), M(3, 1))},
+		{
+			steps:         -4,
+			expectVersion: 1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+			},
+		},
 
 		// apply one migration, then reaches out of boundary
-		{n: -2, expectErr: ErrShortLimit{1}, expectVersion: -1, expectSeq: seq.add(M(1, -1))},
+		{
+			steps:         -2,
+			expectErr:     ErrShortLimit{1},
+			expectVersion: -1,
+			expectSeq: migrationSequence{
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+				mr("CREATE 1"),
+				mr("CREATE 3"),
+				mr("CREATE 4"),
+				mr("CREATE 7"),
+				mr("DROP 7"),
+				mr("DROP 5"),
+				mr("DROP 4"),
+				mr("DROP 1"),
+			},
+		},
 	}
 
 	for i, v := range tt {
-		err := m.Steps(v.n)
+		err := m.Steps(v.steps)
 		if (v.expectErr == os.ErrNotExist && !os.IsNotExist(err)) ||
 			(v.expectErr != os.ErrNotExist && err != v.expectErr) {
 			t.Errorf("expected err %v, got %v, in %v", v.expectErr, err, i)
@@ -357,8 +734,8 @@ func TestSteps(t *testing.T) {
 			} else if v.expectVersion >= 0 && version != uint(v.expectVersion) {
 				t.Errorf("expected version %v, got %v, in %v", v.expectVersion, version, i)
 			}
-			equalDbSeq(t, i, v.expectSeq, dbDrv)
 		}
+		equalDbSeq(t, i, v.expectSeq, dbDrv)
 	}
 }
 
@@ -379,37 +756,114 @@ func TestUpAndDown(t *testing.T) {
 	m, _ := New("stub://", "stub://")
 	m.sourceDrv.(*sStub.Stub).Migrations = sourceStubMigrations
 	dbDrv := m.databaseDrv.(*dStub.Stub)
-	seq := newMigSeq()
 
 	// go Up first
 	if err := m.Up(); err != nil {
 		t.Fatal(err)
 	}
-	equalDbSeq(t, 0, seq.add(M(1), M(3), M(4), M(5), M(7)), dbDrv)
+	expectedSequence := migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+	}
+	equalDbSeq(t, 0, expectedSequence, dbDrv)
 
 	// go Down
 	if err := m.Down(); err != nil {
 		t.Fatal(err)
 	}
-	equalDbSeq(t, 1, seq.add(M(7, 5), M(5, 4), M(4, 3), M(3, 1), M(1, -1)), dbDrv)
+	expectedSequence = migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+	}
+	equalDbSeq(t, 1, expectedSequence, dbDrv)
 
 	// go 1 Up and then all the way Up
 	if err := m.Steps(1); err != nil {
 		t.Fatal(err)
 	}
+	expectedSequence = migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+		mr("CREATE 1"),
+	}
+	equalDbSeq(t, 2, expectedSequence, dbDrv)
+
 	if err := m.Up(); err != nil {
 		t.Fatal(err)
 	}
-	equalDbSeq(t, 2, seq.add(M(1), M(3), M(4), M(5), M(7)), dbDrv)
+	expectedSequence = migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+	}
+	equalDbSeq(t, 3, expectedSequence, dbDrv)
 
 	// go 1 Down and then all the way Down
 	if err := m.Steps(-1); err != nil {
 		t.Fatal(err)
 	}
+	expectedSequence = migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+	}
+	equalDbSeq(t, 1, expectedSequence, dbDrv)
+
 	if err := m.Down(); err != nil {
 		t.Fatal(err)
 	}
-	equalDbSeq(t, 0, seq.add(M(7, 5), M(5, 4), M(4, 3), M(3, 1), M(1, -1)), dbDrv)
+	expectedSequence = migrationSequence{
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+		mr("CREATE 1"),
+		mr("CREATE 3"),
+		mr("CREATE 4"),
+		mr("CREATE 7"),
+		mr("DROP 7"),
+		mr("DROP 5"),
+		mr("DROP 4"),
+		mr("DROP 1"),
+	}
+	equalDbSeq(t, 1, expectedSequence, dbDrv)
 }
 
 func TestUpDirty(t *testing.T) {
@@ -892,6 +1346,8 @@ func (m *migrationSequence) bodySequence() []string {
 			v.Body = ioutil.NopCloser(bytes.NewReader(body))
 
 			r = append(r, string(body[:]))
+		} else {
+			r = append(r, "<empty>")
 		}
 	}
 	return r
@@ -916,6 +1372,13 @@ func M(version uint, targetVersion ...int) *Migration {
 	return migr
 }
 
+// mr is a convenience func to create a new *Migration from the raw database query
+func mr(value string) *Migration {
+	return &Migration{
+		Body: ioutil.NopCloser(bytes.NewReader([]byte(value))),
+	}
+}
+
 func equalMigSeq(t *testing.T, i int, expected, got migrationSequence) {
 	if len(expected) != len(got) {
 		t.Errorf("expected migrations %v, got %v, in %v", expected, got, i)

source/aws_s3/README.md

@@ -1,3 +1,3 @@
-# aws-s3
+# aws_s3
 
 `s3://<bucket>/<prefix>`

source/aws_s3/s3.go

@@ -12,7 +12,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"
 	"github.com/aws/aws-sdk-go/service/s3/s3iface"
-	"github.com/mattes/migrate/source"
+	"github.com/golang-migrate/migrate/source"
 )
 
 func init() {

source/aws_s3/s3_test.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/mattes/migrate/source"
-	st "github.com/mattes/migrate/source/testing"
+	"github.com/golang-migrate/migrate/source"
+	st "github.com/golang-migrate/migrate/source/testing"
 )
 
 func Test(t *testing.T) {

source/driver.go

@@ -87,7 +87,7 @@ func Open(url string) (Driver, error) {
 	d, ok := drivers[u.Scheme]
 	driversMu.RUnlock()
 	if !ok {
-		return nil, fmt.Errorf("source driver: unknown driver %v (forgotton import?)", u.Scheme)
+		return nil, fmt.Errorf("source driver: unknown driver %v (forgotten import?)", u.Scheme)
 	}
 
 	return d.Open(url)
@@ -105,3 +105,14 @@ func Register(name string, driver Driver) {
 	}
 	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
+}