refactor(datastore): back the datastore migration driver with native hanzo-ds/go, drop clickhouse-go

The datastore:// migration driver is now a self-contained golang-migrate database.Driver that opens through github.com/hanzo-ds/go (the native ClickHouse-wire driver registered as the database/sql name "datastore"). The ClickHouse-specific migration logic (multi-statement exec, schema_migrations DDL, cluster/engine config, Version/SetVersion/Drop/Lock) is ported directly into database/datastore, so it no longer embeds or imports the upstream database/clickhouse driver or github.com/ClickHouse/clickhouse-go. - Delete database/clickhouse (driver + test + examples) and internal/cli/build_clickhouse.go. - internal/cli/build_datastore.go drops the clickhouse-go blank import. - go.mod: drop github.com/ClickHouse/clickhouse-go, add github.com/hanzo-ds/go v1.0.1; tidy. Zero clickhouse-go in go.mod, go.sum, and the module/dependency graph. - Port the driver test + example migrations under database/datastore (integration test requires a live datastore/clickhouse-wire backend). - Update README, release workflow build tags, bug report template. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
docs(brand): add hero banner
2026-07-18 18:40:56 -07:00 · 2026-06-28 20:17:58 -07:00 · 2026-06-28 20:17:56 -07:00 · 2026-06-19 20:36:45 -07:00 · 2026-06-17 10:05:12 -07:00 · 2026-06-07 12:10:59 -07:00
208 changed files with 10406 additions and 1830 deletions
@@ -0,0 +1,56 @@
+# Golang CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-go/ for more details
+version: 2.1
+
+jobs:
+  "golang-1_15": &template
+    machine:
+      # https://circleci.com/docs/2.0/configuration-reference/#available-machine-images
+      image: ubuntu-2004:202010-01
+      # docker_layer_caching: true
+
+    # https://circleci.com/docs/2.0/configuration-reference/#resource_class
+    resource_class: medium
+
+    # Leave working directory unspecified and use defaults:
+    # https://circleci.com/blog/go-v1.11-modules-and-circleci/
+    # working_directory: /go/src/github.com/golang-migrate/migrate
+
+    environment:
+      GO111MODULE: "on"
+      GO_VERSION: "1.15.x"
+
+    steps:
+      # - setup_remote_docker:
+      #    version: 19.03.13
+          # docker_layer_caching: true
+      - run: curl -sL -o ~/bin/gimme https://raw.githubusercontent.com/travis-ci/gimme/master/gimme
+      - run: curl -sfL -o ~/bin/golangci-lint.sh https://install.goreleaser.com/github.com/golangci/golangci-lint.sh
+      - run: chmod +x ~/bin/gimme ~/bin/golangci-lint.sh
+      - run: eval "$(gimme $GO_VERSION)"
+      - run: golangci-lint.sh -b ~/bin v1.37.0
+      - checkout
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ arch }}-{{ checksum "go.sum" }}
+      - run: golangci-lint run
+      - run: make test COVERAGE_DIR=/tmp/coverage
+      - save_cache:
+          key: go-mod-v1-{{ arch }}-{{ checksum "go.sum" }}
+          paths:
+            - "/go/pkg/mod"
+      - run: go get github.com/mattn/goveralls
+      - run: goveralls -service=circle-ci -coverprofile /tmp/coverage/combined.txt
+
+  "golang-1_16":
+    <<: *template
+    environment:
+      GO_VERSION: "1.16.x"
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "golang-1_15"
+      - "golang-1_16"
@@ -25,7 +25,7 @@ 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
+e.g. spanner, stub, datastore, cockroachdb, crdb-postgres, postgres, postgresql, pgx, redshift, cassandra, cockroach, mysql
 Obtained by running: `migrate -help`

 **Go Version**
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1280" height="640" viewBox="0 0 1280 640" role="img" aria-label="migrate">
+<rect width="1280" height="640" fill="#0A0A0A"/>
+<svg x="96" y="215" width="210" height="210" viewBox="0 0 67 67"><path d="M22.21 67V44.6369H0V67H22.21Z" fill="#fff"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="#fff"/><path d="M22.21 0H0V22.3184H22.21V0Z" fill="#fff"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="#fff"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="#fff"/></svg>
+<text x="378" y="276" font-family="Inter,system-ui,-apple-system,sans-serif" font-size="78" font-weight="800" letter-spacing="-2" fill="#ffffff">migrate</text>
+<text x="378" y="322" font-family="Inter,system-ui,sans-serif" font-size="30" fill="#ffffff" opacity=".66">Database migrations. CLI and Golang library.</text>
+<rect x="378" y="338" width="806" height="3" rx="1.5" fill="#ffffff" opacity=".9"/>
+<text x="378" y="390" font-family="Inter,system-ui,sans-serif" font-size="24" font-weight="600" fill="#ffffff" opacity=".5">github.com/hanzoai</text>
+<text x="1184" y="390" text-anchor="end" font-family="Inter,system-ui,sans-serif" font-size="24" font-weight="600" fill="#ffffff" opacity=".5">hanzo.ai</text>
+</svg>
@@ -0,0 +1,111 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  lint:
+    name: lint
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.26.4.x"
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.6.2
+
+  test:
+    runs-on: hanzo-build-linux-amd64
+    strategy:
+      matrix:
+        go: ["1.24.x", "1.25.x"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go }}
+
+      - name: Run test
+        run: make test COVERAGE_DIR=/tmp/coverage
+
+      - name: Send goveralls coverage
+        uses: shogo82148/actions-goveralls@v1
+        with:
+          path-to-profile: /tmp/coverage/combined.txt
+          flag-name: Go-${{ matrix.go }}
+          parallel: true
+
+  check-coverage:
+    name: Check coverage
+    needs: [test]
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - uses: shogo82148/actions-goveralls@v1
+        with:
+          parallel-finished: true
+
+  goreleaser:
+    name: Release a new version
+    needs: [lint, test]
+    runs-on: hanzo-build-linux-amd64
+    environment: GoReleaser
+    # This job only runs when
+    # 1. When the previous `lint` and `test` jobs has completed successfully
+    # 2. When the repository is not a fork, i.e. it will only run on the official golang-migrate/migrate
+    # 3. When the workflow is triggered by a tag with `v` prefix
+    if: ${{ success() && github.repository == 'golang-migrate/migrate' && startsWith(github.ref, 'refs/tags/v') }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.26.4.x"
+
+      - uses: docker/setup-qemu-action@v3
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          username: golangmigrate
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - run: echo "SOURCE=$(make echo-source)" >> $GITHUB_ENV
+      - run: echo "DATABASE=$(make echo-database)" >> $GITHUB_ENV
+
+      - uses: goreleaser/goreleaser-action@v5
+        with:
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - run: gem install package_cloud
+      - run: package_cloud push golang-migrate/migrate/ubuntu/bionic dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/ubuntu/focal dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/ubuntu/jammy dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/ubuntu/noble dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/debian/buster dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/debian/bullseye dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
+      - run: package_cloud push golang-migrate/migrate/debian/bookworm dist/migrate.linux-amd64.deb
+        env:
+          PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_TOKEN }}
@@ -0,0 +1,52 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  release:
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.26.4'
+
+      - name: Build CLI binaries
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          mkdir -p cli/build
+
+          for pair in "linux/amd64" "linux/arm64" "darwin/amd64" "darwin/arm64"; do
+            OS=${pair%/*}
+            ARCH=${pair#*/}
+            OUTPUT="cli/build/migrate.${OS}-${ARCH}"
+            echo "Building $OUTPUT..."
+            CGO_ENABLED=0 GOOS=$OS GOARCH=$ARCH \
+              go build -a -o "$OUTPUT" \
+              -ldflags="-s -w -X main.Version=$VERSION" \
+              -tags 'datastore file' \
+              ./cmd/migrate
+            ln -f "$OUTPUT" cli/build/migrate
+            tar czf "${OUTPUT}.tar.gz" -C cli/build migrate
+          done
+
+          cd cli/build && sha256sum *.tar.gz > sha256sum.txt
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create ${{ github.ref_name }} \
+            cli/build/*.tar.gz \
+            cli/build/sha256sum.txt \
+            --title "${{ github.ref_name }}" \
+            --generate-notes \
+            --latest
@@ -6,4 +6,6 @@ cli/migrate
 .godoc.pid
 vendor/
 .vscode/
-.idea/
+.idea
+dist/
+migrate
@@ -1,27 +1,37 @@
-run:
-  # timeout for analysis, e.g. 30s, 5m, default is 1m
-  timeout: 2m
+version: "2"
 linters:
  enable:
-    #- golint
-    - interfacer
-    - unconvert
-    #- dupl
    - goconst
-    - gofmt
    - misspell
-    - maligned
-    - unparam
    - nakedret
    - prealloc
-    #- gosec
-linters-settings:
-  misspell:
-    locale: US
+    - revive
+    - unconvert
+    - unparam
+  settings:
+    misspell:
+      locale: US
+    revive:
+      rules:
+        - name: redundant-build-tag
+  exclusions:
+    generated: lax
+    rules:
+      - path: (.+)\.go$
+        text: G104
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
 issues:
-  max-same: 0
-  max-per-linter: 0
-  exclude-use-default: false
-  exclude:
-    # gosec: Duplicated errcheck checks
-    - G104
+  max-issues-per-linter: 0
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofmt
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
@@ -0,0 +1,102 @@
+project_name: migrate
+before:
+  hooks:
+    - go mod tidy
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+    goarch:
+      - amd64
+      - arm
+      - arm64
+      - 386
+    goarm:
+      - 7
+    main: ./cmd/migrate
+    ldflags:
+      - '-w -s -X main.Version={{ .Version }} -extldflags "static"'
+    flags:
+      - "-tags={{ .Env.DATABASE }} {{ .Env.SOURCE }}"
+      - "-trimpath"
+nfpms:
+  - homepage: "https://github.com/golang-migrate/migrate"
+    maintainer: "dhui@users.noreply.github.com"
+    license: MIT
+    description: "Database migrations"
+    formats:
+      - deb
+    file_name_template: "{{ .ProjectName }}.{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+dockers:
+  - goos: linux
+    goarch: amd64
+    dockerfile: Dockerfile.github-actions
+    use: buildx
+    ids:
+      - migrate
+    image_templates:
+      - 'migrate/migrate:{{ .Tag }}-amd64'
+    build_flag_templates:
+      - '--label=org.opencontainers.image.created={{ .Date }}'
+      - '--label=org.opencontainers.image.title={{ .ProjectName }}'
+      - '--label=org.opencontainers.image.revision={{ .FullCommit }}'
+      - '--label=org.opencontainers.image.version={{ .Version }}'
+      - "--label=org.opencontainers.image.source={{ .GitURL }}"
+      - "--platform=linux/amd64"
+  - goos: linux
+    goarch: arm64
+    dockerfile: Dockerfile.github-actions
+    use: buildx
+    ids:
+      - migrate
+    image_templates:
+      - 'migrate/migrate:{{ .Tag }}-arm64'
+    build_flag_templates:
+      - '--label=org.opencontainers.image.created={{ .Date }}'
+      - '--label=org.opencontainers.image.title={{ .ProjectName }}'
+      - '--label=org.opencontainers.image.revision={{ .FullCommit }}'
+      - '--label=org.opencontainers.image.version={{ .Version }}'
+      - "--label=org.opencontainers.image.source={{ .GitURL }}"
+      - "--platform=linux/arm64"
+
+docker_manifests:
+- name_template: 'migrate/migrate:{{ .Tag }}'
+  image_templates:
+  - 'migrate/migrate:{{ .Tag }}-amd64'
+  - 'migrate/migrate:{{ .Tag }}-arm64'
+- name_template: 'migrate/migrate:{{ .Major }}'
+  image_templates:
+  - 'migrate/migrate:{{ .Tag }}-amd64'
+  - 'migrate/migrate:{{ .Tag }}-arm64'
+- name_template: 'migrate/migrate:latest'
+  image_templates:
+  - 'migrate/migrate:{{ .Tag }}-amd64'
+  - 'migrate/migrate:{{ .Tag }}-arm64'
+archives:
+  - name_template: "{{ .ProjectName }}.{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+    format_overrides:
+      - goos: windows
+        format: zip
+checksum:
+  name_template: 'sha256sum.txt'
+release:
+  draft: true
+  prerelease: auto
+source:
+  enabled: true
+  format: zip
+changelog:
+  skip: false
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+      - Merge pull request
+      - Merge branch
+      - go mod tidy
+snapshot:
+  name_template: "{{ .Tag }}-next"
@@ -0,0 +1 @@
+LLM.md
@@ -0,0 +1 @@
+LLM.md
@@ -1,4 +1,4 @@
-FROM golang:1.15-alpine3.12 AS builder
+FROM golang:1.26.4-alpine3.21 AS builder
 ARG VERSION

 RUN apk add --no-cache git gcc musl-dev make
@@ -15,7 +15,7 @@ COPY . ./

 RUN make build-docker

-FROM alpine:3.12
+FROM alpine:3.21

 RUN apk add --no-cache ca-certificates

@@ -0,0 +1,17 @@
+ARG DOCKER_IMAGE
+FROM $DOCKER_IMAGE
+
+RUN apk add --no-cache git gcc musl-dev make
+
+WORKDIR /go/src/github.com/golang-migrate/migrate
+
+ENV GO111MODULE=on
+ENV COVERAGE_DIR=/tmp/coverage
+
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY . ./
+
+CMD ["make", "test"]
@@ -0,0 +1,11 @@
+FROM alpine:3.19
+
+RUN apk add --no-cache ca-certificates
+
+COPY migrate /usr/local/bin/migrate
+
+RUN ln -s /usr/local/bin/migrate /usr/bin/migrate
+RUN ln -s /usr/local/bin/migrate /migrate
+
+ENTRYPOINT ["migrate"]
+CMD ["--help"]
@@ -50,7 +50,7 @@
  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.
+  Yes, technically thats possible. We want to encourage you to contribute your driver to this repository 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
@@ -65,7 +65,7 @@
  and then "force" the expected version.

 #### What happens if two programs try and update the database at the same time?
-Database-specific locking features are used by *some* database drivers to prevent multiple instances of migrate from running migrations at the same time
+  Database-specific locking features are used by *some* database drivers to prevent multiple instances of migrate from running migrations on
  the same database at the same time. For example, the MySQL driver uses the `GET_LOCK` function, while the Postgres driver uses
  the `pg_advisory_lock` function.

@@ -1,7 +1,7 @@
 # Getting started
 Before you start, you should understand the concept of forward/up and reverse/down database migrations.

-Configure a database for your application. Make sure that your database driver is supported [here](README.md#databases)
+Configure a database for your application. Make sure that your database driver is supported [here](README.md#databases).

 ## Create migrations
 Create some migrations using migrate CLI. Here is an example:
@@ -10,7 +10,7 @@ migrate create -ext sql -dir db/migrations -seq create_users_table
 ```
 Once you create your files, you should fill them.

-**IMPORTANT:** In a project developed by more than one person there is a chance of migrations inconsistency - e.g. two developers can create conflicting migrations, and the developer that created his migration later gets it merged to the repository first.
+**IMPORTANT:** In a project developed by more than one person there is a chance of migrations inconsistency - e.g. two developers can create conflicting migrations, and the developer that created their migration later gets it merged to the repository first.
 Developers and Teams should keep an eye on such cases (especially during code review).
 [Here](https://github.com/golang-migrate/migrate/issues/179#issuecomment-475821264) is the issue summary if you would like to read more.

@@ -28,9 +28,9 @@ migrate -database YOUR_DATABASE_URL -path PATH_TO_YOUR_MIGRATIONS up

 Just add the code to your app and you're ready to go!

-Before commiting your migrations you should run your migrations up, down, and then up again to see if migrations are working properly both ways.
+Before committing your migrations you should run your migrations up, down, and then up again to see if migrations are working properly both ways.
 (e.g. if you created a table in a migration but reverse migration did not delete it, you will encounter an error when running the forward migration again)
-It's also worth checking your migrations in a separate, containerized environment. You can find some tools in the end of this document.
+It's also worth checking your migrations in a separate, containerized environment. You can find some tools at the [end of this document](#further-reading).

 **IMPORTANT:** If you would like to run multiple instances of your app on different machines be sure to use a database that supports locking when running migrations. Otherwise you may encounter issues.

@@ -0,0 +1,39 @@
+# Hanzo Golang Migrate
+
+## Overview
+Go module: github.com/golang-migrate/migrate/v4
+
+## Tech Stack
+- **Language**: Go
+
+## Build & Run
+```bash
+go build ./...
+go test ./...
+```
+
+## Structure
+```
+golang-migrate/
+  CONTRIBUTING.md
+  Dockerfile
+  Dockerfile.circleci
+  Dockerfile.github-actions
+  FAQ.md
+  GETTING_STARTED.md
+  LICENSE
+  MIGRATIONS.md
+  Makefile
+  README.md
+  SECURITY.md
+  cli/
+  cmd/
+  database/
+  dktesting/
+```
+
+## Key Files
+- `README.md` -- Project documentation
+- `go.mod` -- Go module definition
+- `Makefile` -- Build automation
+- `Dockerfile` -- Container build
@@ -1,6 +1,6 @@
-SOURCE ?= file go_bindata github github_ee aws_s3 google_cloud_storage godoc_vfs gitlab
-DATABASE ?= postgres mysql redshift cassandra spanner cockroachdb clickhouse mongodb sqlserver firebird neo4j
-DATABASE_TEST ?= $(DATABASE) sqlite sqlcipher
+SOURCE ?= file go_bindata github github_ee bitbucket aws_s3 google_cloud_storage godoc_vfs gitlab
+DATABASE ?= postgres mysql redshift cassandra spanner cockroachdb yugabytedb datastore mongodb sqlserver firebird neo4j pgx pgx5 rqlite
+DATABASE_TEST ?= $(DATABASE) sqlite sqlite3 sqlcipher
 VERSION ?= $(shell git describe --tags 2>/dev/null | cut -c 2-)
 TEST_FLAGS ?=
 REPO_OWNER ?= $(shell cd .. && basename "$$(pwd)")
@@ -98,6 +98,12 @@ release:
 	git tag v$(V)
 	@read -p "Press enter to confirm and push to origin ..." && git push origin v$(V)

+echo-source:
+	@echo "$(SOURCE)"
+
+echo-database:
+	@echo "$(DATABASE)"
+

 define external_deps
 	@echo '-- $(1)';  go list -f '{{join .Deps "\n"}}' $(1) | grep -v github.com/$(REPO_OWNER)/migrate | xargs go list -f '{{if not .Standard}}{{.ImportPath}}{{end}}'
@@ -107,7 +113,7 @@ endef

 .PHONY: build build-docker 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
+		docs kill-docs open-docs kill-orphaned-docker-containers echo-source echo-database

 SHELL = /bin/sh
 RAND = $(shell echo $$RANDOM)
@@ -1,11 +1,13 @@
-[![Build Status](https://img.shields.io/travis/com/golang-migrate/migrate/master.svg)](https://travis-ci.com/golang-migrate/migrate)
-[![GoDoc](https://godoc.org/github.com/golang-migrate/migrate?status.svg)](https://godoc.org/github.com/golang-migrate/migrate)
+<p align="center"><img src=".github/hero.svg" alt="migrate" width="880"></p>
+
+[![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/golang-migrate/migrate/ci.yaml?branch=master)](https://github.com/golang-migrate/migrate/actions/workflows/ci.yaml?query=branch%3Amaster)
+[![GoDoc](https://pkg.go.dev/badge/github.com/golang-migrate/migrate)](https://pkg.go.dev/github.com/golang-migrate/migrate/v4)
 [![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.14%2C%201.15-lightgrey.svg)
+![Supported Go Versions](https://img.shields.io/badge/Go-1.24%2C%201.25-lightgrey.svg)
 [![GitHub Release](https://img.shields.io/github/release/golang-migrate/migrate.svg)](https://github.com/golang-migrate/migrate/releases)
-[![Go Report Card](https://goreportcard.com/badge/github.com/golang-migrate/migrate)](https://goreportcard.com/report/github.com/golang-migrate/migrate)
+[![Go Report Card](https://goreportcard.com/badge/github.com/golang-migrate/migrate/v4)](https://goreportcard.com/report/github.com/golang-migrate/migrate/v4)

 # migrate

@@ -24,21 +26,26 @@ Forked from [mattes/migrate](https://github.com/mattes/migrate)
 Database drivers run migrations. [Add a new database?](database/driver.go)

 * [PostgreSQL](database/postgres)
+* [PGX v4](database/pgx)
+* [PGX v5](database/pgx/v5)
 * [Redshift](database/redshift)
 * [Ql](database/ql)
-* [Cassandra](database/cassandra)
-* [SQLite](database/sqlite3) ([todo #165](https://github.com/mattes/migrate/issues/165))
+* [Cassandra / ScyllaDB](database/cassandra)
+* [SQLite](database/sqlite)
+* [SQLite3](database/sqlite3) ([todo #165](https://github.com/mattes/migrate/issues/165))
 * [SQLCipher](database/sqlcipher)
-* [MySQL/ MariaDB](database/mysql)
+* [MySQL / MariaDB](database/mysql)
 * [Neo4j](database/neo4j)
 * [MongoDB](database/mongodb)
 * [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)
 * [CockroachDB](database/cockroachdb)
-* [ClickHouse](database/clickhouse)
+* [YugabyteDB](database/yugabytedb)
+* [Datastore](database/datastore)
 * [Firebird](database/firebird)
 * [MS SQL Server](database/sqlserver)
+* [rqlite](database/rqlite)

 ### Database URLs

@@ -66,9 +73,12 @@ $
 Source drivers read migrations from local or remote sources. [Add a new source?](source/driver.go)

 * [Filesystem](source/file) - read from filesystem
+* [io/fs](source/iofs) - read from a Go [io/fs](https://pkg.go.dev/io/fs#FS)
 * [Go-Bindata](source/go_bindata) - read from embedded binary data ([jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata))
+* [pkger](source/pkger) - read from embedded binary data ([markbates/pkger](https://github.com/markbates/pkger))
 * [GitHub](source/github) - read from remote GitHub repositories
 * [GitHub Enterprise](source/github_ee) - read from remote GitHub Enterprise repositories
+* [Bitbucket](source/bitbucket) - read from remote Bitbucket repositories
 * [Gitlab](source/gitlab) - read from remote Gitlab 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
@@ -79,7 +89,7 @@ Source drivers read migrations from local or remote sources. [Add a new source?]
 * Handles ctrl+c (SIGINT) gracefully.
 * No config search paths, no config files, no magic ENV var injections.

-__[CLI Documentation](cmd/migrate)__
+[CLI Documentation](cmd/migrate) (includes CLI install instructions)

 ### Basic usage

@@ -103,7 +113,7 @@ $ docker run -v {{ migration dir }}:/migrations --network host migrate/migrate
 * Uses `io.Reader` streams internally for low memory overhead.
 * Thread-safe and no goroutine leaks.

-__[Go Documentation](https://godoc.org/github.com/golang-migrate/migrate)__
+__[Go Documentation](https://pkg.go.dev/github.com/golang-migrate/migrate/v4)__

 ```go
 import (
@@ -137,7 +147,7 @@ func main() {
    m, err := migrate.NewWithDatabaseInstance(
        "file:///migrations",
        "postgres", driver)
-    m.Steps(2)
+    m.Up() // or m.Steps(2) if you want to explicitly set the number of migrations to run
 }
 ```

@@ -163,6 +173,11 @@ Each migration has an up and down migration. [Why?](FAQ.md#why-two-separate-file

 [Best practices: How to write migrations.](MIGRATIONS.md)

+## Coming from another db migration tool?
+
+Check out [migradaptor](https://github.com/musinit/migradaptor/).
+*Note: migradaptor is not affiliated or supported by this project*
+
 ## Versions

 Version | Supported? | Import | Notes
@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| master  | :white_check_mark: |
+| 4.x     | :white_check_mark: |
+| 3.x     | :x:                |
+| < 3.0   | :x:                |
+
+## Reporting a Vulnerability
+
+We prefer [coordinated disclosures](https://en.wikipedia.org/wiki/Coordinated_vulnerability_disclosure). To start one, create a GitHub security advisory following [these instructions](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability)
+
+Please suggest potential impact and urgency in your reports.
@@ -7,7 +7,7 @@
 [Release Downloads](https://github.com/golang-migrate/migrate/releases)

 ```bash
-$ curl -L https://github.com/golang-migrate/migrate/releases/download/$version/migrate.$platform-amd64.tar.gz | tar xvz
+$ curl -L https://github.com/golang-migrate/migrate/releases/download/$version/migrate.$os-$arch.tar.gz | tar xvz
 ```

 ### MacOS
@@ -27,8 +27,8 @@ $ scoop install migrate
 ### Linux (*.deb package)

 ```bash
-$ curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey | apt-key add -
-$ echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/migrate.list
+$ curl -fsSL https://packagecloud.io/golang-migrate/migrate/gpgkey | sudo gpg --dearmor -o /etc/apt/keyrings/migrate.gpg
+$ echo "deb [signed-by=/etc/apt/keyrings/migrate.gpg] https://packagecloud.io/golang-migrate/migrate/ubuntu/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/migrate.list
 $ apt-get update
 $ apt-get install -y migrate
 ```
@@ -41,13 +41,19 @@ $ apt-get install -y migrate
 $ go get -u -d github.com/golang-migrate/migrate/cmd/migrate
 $ cd $GOPATH/src/github.com/golang-migrate/migrate/cmd/migrate
 $ git checkout $TAG  # e.g. v4.1.0
+$ # Go 1.15 and below
 $ go build -tags 'postgres' -ldflags="-X main.Version=$(git describe --tags)" -o $GOPATH/bin/migrate $GOPATH/src/github.com/golang-migrate/migrate/cmd/migrate
+$ # Go 1.16+
+$ go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@$TAG
 ```

 #### Unversioned

 ```bash
+$ # Go 1.15 and below
 $ go get -tags 'postgres' -u github.com/golang-migrate/migrate/cmd/migrate
+$ # Go 1.16+
+$ go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@latest
 ```

 #### Notes
@@ -57,9 +63,10 @@ $ go get -tags 'postgres' -u github.com/golang-migrate/migrate/cmd/migrate
 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.
+[`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
+1. For versions of Go 1.15 and lower, [make sure](https://github.com/golang-migrate/migrate/pull/257#issuecomment-705249902) you're not installing the `migrate` CLI from a module. e.g. there should not be any `go.mod` files in your current directory or any directory from your current directory to the root

 ## Usage

@@ -79,14 +86,18 @@ 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.
+  create [-ext E] [-dir D] [-seq] [-digits N] [-format] [-tz] 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. Note: migrations with the same time cause "duplicate migration version" error.
+           Use -tz option to specify the timezone that will be used when generating non-sequential migrations (defaults: UTC).
+
  goto V       Migrate to version V
  up [N]       Apply all or N up migrations
-  down [N]     Apply all or N down migrations
-  drop         Drop everything inside database
+  down [N] [-all]    Apply all or N down migrations
+        Use -all to apply all down migrations
+  drop [-f]    Drop everything inside database
+        Use -f to bypass confirmation
  force V      Set version V but don't run migration (ignores dirty state)
  version      Print current migration version
 ```
@@ -120,7 +131,7 @@ $ migrate -database "$MY_MIGRATE_DATABASE"
 Check out https://stedolan.github.io/jq/

 ```bash
-$ migrate -database "$(cat config.json | jq '.database')"
+$ migrate -database "$(cat config.json | jq -r '.database')"
 ```

 ### YAML files
@@ -1,12 +1,17 @@
-# Cassandra
+# Cassandra / ScyllaDB

-* Drop command will not work on Cassandra 2.X because it rely on
+* `Drop()` method 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**
+* Other methods should work properly but are **not tested**
 * The Cassandra driver (gocql) does not natively support executing multiple 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.

+**ScyllaDB**
+
+* No additional configuration is required since it is a drop-in replacement for Cassandra.
+* The `Drop()` method` works for ScyllaDB 5.1
+

 ## Usage
 `cassandra://host:port/keyspace?param1=value&param2=value2`
@@ -20,12 +25,14 @@ system_schema table which comes with 3.X
 | `consistency` | ALL | Migration consistency
 | `protocol` |  | Cassandra protocol version (3 or 4)
 | `timeout` | 1 minute | Migration timeout
+| `connect-timeout` | 600ms | Initial connection timeout to the cluster |
 | `username` | nil | Username to use when authenticating. |
 | `password` | nil | Password to use when authenticating. |
 | `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) |
+| `disable-host-lookup`| false | Disable initial host lookup. |

 `timeout` is parsed using [time.ParseDuration(s string)](https://golang.org/pkg/time/#ParseDuration)

@@ -4,16 +4,15 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"

 	"github.com/gocql/gocql"
 	"github.com/golang-migrate/migrate/v4/database"
 	"github.com/golang-migrate/migrate/v4/database/multistmt"
-	"github.com/hashicorp/go-multierror"
 )

 func init() {
@@ -45,7 +44,7 @@ type Config struct {

 type Cassandra struct {
 	session  *gocql.Session
-	isLocked bool
+	isLocked atomic.Bool

 	// Open and WithInstance need to guarantee that config is never nil
 	config *Config
@@ -132,6 +131,14 @@ func (c *Cassandra) Open(url string) (database.Driver, error) {
 		}
 		cluster.Timeout = timeout
 	}
+	if len(u.Query().Get("connect-timeout")) > 0 {
+		var connectTimeout time.Duration
+		connectTimeout, err = time.ParseDuration(u.Query().Get("connect-timeout"))
+		if err != nil {
+			return nil, err
+		}
+		cluster.ConnectTimeout = connectTimeout
+	}

 	if len(u.Query().Get("sslmode")) > 0 {
 		if u.Query().Get("sslmode") != "disable" {
@@ -155,6 +162,14 @@ func (c *Cassandra) Open(url string) (database.Driver, error) {
 		}
 	}

+	if len(u.Query().Get("disable-host-lookup")) > 0 {
+		if flag, err := strconv.ParseBool(u.Query().Get("disable-host-lookup")); err != nil && flag {
+			cluster.DisableInitialHostLookup = true
+		} else if err != nil {
+			return nil, err
+		}
+	}
+
 	session, err := cluster.CreateSession()
 	if err != nil {
 		return nil, err
@@ -182,15 +197,16 @@ func (c *Cassandra) Close() error {
 }

 func (c *Cassandra) Lock() error {
-	if c.isLocked {
+	if !c.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	c.isLocked = true
 	return nil
 }

 func (c *Cassandra) Unlock() error {
-	c.isLocked = false
+	if !c.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
 	return nil
 }

@@ -213,7 +229,7 @@ func (c *Cassandra) Run(migration io.Reader) error {
 		return err
 	}

-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -226,16 +242,26 @@ func (c *Cassandra) Run(migration io.Reader) error {
 }

 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)}
+	// DELETE instead of TRUNCATE because AWS Keyspaces does not support it
+	// see: https://docs.aws.amazon.com/keyspaces/latest/devguide/cassandra-apis.html
+	squery := `SELECT version FROM "` + c.config.MigrationsTable + `"`
+	dquery := `DELETE FROM "` + c.config.MigrationsTable + `" WHERE version = ?`
+	iter := c.session.Query(squery).Iter()
+	var previous int
+	for iter.Scan(&previous) {
+		if err := c.session.Query(dquery, previous).Exec(); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(dquery)}
+		}
+	}
+	if err := iter.Close(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(squery)}
 	}

 	// Also re-write the schema version for nil dirty versions to prevent
 	// empty schema version for failed down migration on the first migration
 	// See: https://github.com/golang-migrate/migrate/issues/330
 	if version >= 0 || (version == database.NilVersion && dirty) {
-		query = `INSERT INTO "` + c.config.MigrationsTable + `" (version, dirty) VALUES (?, ?)`
+		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)}
 		}
@@ -288,11 +314,7 @@ func (c *Cassandra) ensureVersionTable() (err error) {

 	defer func() {
 		if e := c.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -314,7 +336,7 @@ func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err
 			var ok bool
 			err, ok = r.(error)
 			if !ok {
-				err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)
+				err = fmt.Errorf("failed to parse consistency \"%s\": %v", consistencyStr, r)
 			}
 		}
 	}()
@@ -25,9 +25,11 @@ var (
 	// Although Cassandra 2.x is supported by the Apache Foundation,
 	// the migrate db driver only supports Cassandra 3.x since it uses
 	// the system_schema keyspace.
+	// last ScyllaDB version tested is 5.1.11
 	specs = []dktesting.ContainerSpec{
 		{ImageName: "cassandra:3.0", Options: opts},
 		{ImageName: "cassandra:3.11", Options: opts},
+		{ImageName: "scylladb/scylla:5.1.11", Options: opts},
 	}
 )

@@ -59,6 +61,20 @@ func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
 }

 func Test(t *testing.T) {
+	t.Run("test", test)
+	t.Run("testMigrate", testMigrate)
+
+	t.Cleanup(func() {
+		for _, spec := range specs {
+			t.Log("Cleaning up ", spec.ImageName)
+			if err := spec.Cleanup(); err != nil {
+				t.Error("Error removing ", spec.ImageName, "error:", err)
+			}
+		}
+	})
+}
+
+func test(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.Port(9042)
 		if err != nil {
@@ -79,7 +95,7 @@ func Test(t *testing.T) {
 	})
 }

-func TestMigrate(t *testing.T) {
+func testMigrate(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.Port(9042)
 		if err != nil {
@@ -1,19 +0,0 @@
-# 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.
@@ -1,260 +0,0 @@
-package clickhouse
-
-import (
-	"database/sql"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/golang-migrate/migrate/v4"
-	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/golang-migrate/migrate/v4/database/multistmt"
-	"github.com/hashicorp/go-multierror"
-)
-
-var (
-	multiStmtDelimiter = []byte(";")
-
-	DefaultMigrationsTable       = "schema_migrations"
-	DefaultMultiStatementMaxSize = 10 * 1 << 20 // 10 MB
-
-	ErrNilConfig = fmt.Errorf("no config")
-)
-
-type Config struct {
-	DatabaseName          string
-	MigrationsTable       string
-	MultiStatementEnabled bool
-	MultiStatementMaxSize int
-}
-
-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
-	}
-
-	multiStatementMaxSize := DefaultMultiStatementMaxSize
-	if s := purl.Query().Get("x-multi-statement-max-size"); len(s) > 0 {
-		multiStatementMaxSize, err = strconv.Atoi(s)
-		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",
-			MultiStatementMaxSize: multiStatementMaxSize,
-		},
-	}
-
-	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
-	}
-
-	if ch.config.MultiStatementMaxSize <= 0 {
-		ch.config.MultiStatementMaxSize = DefaultMultiStatementMaxSize
-	}
-
-	return ch.ensureVersionTable()
-}
-
-func (ch *ClickHouse) Run(r io.Reader) error {
-	if ch.config.MultiStatementEnabled {
-		var err error
-		if e := multistmt.Parse(r, multiStmtDelimiter, ch.config.MultiStatementMaxSize, func(m []byte) bool {
-			tq := strings.TrimSpace(string(m))
-			if tq == "" {
-				return true
-			}
-			if _, e := ch.conn.Exec(string(m)); e != nil {
-				err = database.Error{OrigErr: e, Err: "migration failed", Query: m}
-				return false
-			}
-			return true
-		}); e != nil {
-			return e
-		}
-		return err
-	}
-
-	migration, err := ioutil.ReadAll(r)
-	if err != nil {
-		return err
-	}
-
-	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()
-}
-
-// ensureVersionTable checks if versions table exists and, if not, creates it.
-// Note that this function locks the database, which deviates from the usual
-// convention of "caller locks" in the ClickHouse type.
-func (ch *ClickHouse) ensureVersionTable() (err error) {
-	if err = ch.Lock(); err != nil {
-		return err
-	}
-
-	defer func() {
-		if e := ch.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
-		}
-	}()
-
-	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    Int64, 
-			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() (err error) {
-	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 func() {
-		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
-		}
-	}()
-	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 nil
-}
-
-func (ch *ClickHouse) Lock() error   { return nil }
-func (ch *ClickHouse) Unlock() error { return nil }
-func (ch *ClickHouse) Close() error  { return ch.conn.Close() }
@@ -15,7 +15,7 @@ CREATE USER IF NOT EXISTS cockroach;
 GRANT ALL ON DATABASE example TO cockroach;
 ```

-When using Migrate CLI we need to pass to database URL. Let's export it to a variable for convienience:
+When using Migrate CLI we need to pass to database URL. Let's export it to a variable for convenience:
 ```
 export COCKROACHDB_URL='cockroachdb://cockroach:@localhost:26257/example?sslmode=disable'
 ```
@@ -50,7 +50,7 @@ And in the `.down.sql` let's delete it:
 ```
 DROP TABLE IF EXISTS example.users;
 ```
-By adding `IF EXISTS/IF NOT EXISTS` we are making migrations idempotent - you can read more about idempotency in [getting started](GETTING_STARTED.md#create-migrations)
+By adding `IF EXISTS/IF NOT EXISTS` we are making migrations idempotent - you can read more about idempotency in [getting started](/GETTING_STARTED.md#create-migrations)

 ## Run migrations
 ```
@@ -139,4 +139,4 @@ func main() {
 	}
 }
 ```
-You can find details [here](README.md#use-in-your-go-project)
+You can find details [here](README.md#use-in-your-go-project)
@@ -3,23 +3,18 @@ package cockroachdb
 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"regexp"
 	"strconv"
-)
+	"sync/atomic"

-import (
-	"github.com/cockroachdb/cockroach-go/crdb"
-	"github.com/hashicorp/go-multierror"
-	"github.com/lib/pq"
-)
-
-import (
+	"github.com/cockroachdb/cockroach-go/v2/crdb"
 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/lib/pq"
 )

 func init() {
@@ -46,7 +41,7 @@ type Config struct {

 type CockroachDb struct {
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	// Open and WithInstance need to guarantee that config is never nil
 	config *Config
@@ -152,75 +147,71 @@ func (c *CockroachDb) Close() error {
 // 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) (err 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 func() {
-			if errClose := rows.Close(); errClose != nil {
-				err = multierror.Append(err, errClose)
+	return database.CasRestoreOnErr(&c.isLocked, false, true, database.ErrLocked, func() (err error) {
+		return crdb.ExecuteTx(context.Background(), c.db, nil, func(tx *sql.Tx) (err error) {
+			aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+			if err != nil {
+				return err
 			}
-		}()

-		// If row exists at all, lock is present
-		locked := rows.Next()
-		if locked && !c.config.ForceLock {
-			return database.ErrLocked
-		}
+			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 func() {
+				if errClose := rows.Close(); errClose != nil {
+					err = errors.Join(err, errClose)
+				}
+			}()

-		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)}
-		}
+			// If row exists at all, lock is present
+			locked := rows.Next()
+			if locked && !c.config.ForceLock {
+				return database.ErrLocked
+			}

-		return nil
+			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.CasRestoreOnErr(&c.isLocked, true, false, database.ErrNotLocked, func() (err error) {
+		aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+		if err != nil {
+			return err
 		}
-		return database.Error{OrigErr: err, Err: "failed to release migration lock", Query: []byte(query)}
-	}

-	c.isLocked = false
-	return nil
+		// 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
+					return nil
+				}
+			}
+
+			return database.Error{OrigErr: err, Err: "failed to release migration lock", Query: []byte(query)}
+		}
+
+		return nil
+	})
 }

 func (c *CockroachDb) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -285,7 +276,7 @@ func (c *CockroachDb) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -300,6 +291,9 @@ func (c *CockroachDb) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	if len(tableNames) > 0 {
 		// delete one by one ...
@@ -324,11 +318,7 @@ func (c *CockroachDb) ensureVersionTable() (err error) {

 	defer func() {
 		if e := c.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -26,13 +26,13 @@ import (
 const defaultPort = 26257

 var (
-	opts = dktest.Options{Cmd: []string{"start", "--insecure"}, PortRequired: true, ReadyFunc: isReady}
-	// Released versions: https://www.cockroachlabs.com/docs/releases/
+	opts = dktest.Options{Cmd: []string{"start-single-node", "--insecure"}, PortRequired: true, ReadyFunc: isReady}
+	// Supported versions: https://www.cockroachlabs.com/docs/releases/release-support-policy#supported-versions
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "cockroachdb/cockroach:v1.0.7", Options: opts},
-		{ImageName: "cockroachdb/cockroach:v1.1.9", Options: opts},
-		{ImageName: "cockroachdb/cockroach:v2.0.7", Options: opts},
-		{ImageName: "cockroachdb/cockroach:v2.1.3", Options: opts},
+		{ImageName: "cockroachdb/cockroach:latest-v24.3", Options: opts},
+		{ImageName: "cockroachdb/cockroach:latest-v24.1", Options: opts},
+		{ImageName: "cockroachdb/cockroach:latest-v23.2", Options: opts},
+		{ImageName: "cockroachdb/cockroach:latest-v23.1", Options: opts},
 	}
 )

@@ -0,0 +1,31 @@
+# Datastore
+
+`datastore://host:port?username=user&password=password&database=clicks&x-multi-statement=true`
+
+Hanzo Datastore is a ClickHouse-wire-compatible database engine. This driver
+connects through the native `github.com/hanzo-ds/go` driver, which registers the
+`database/sql` driver name `datastore`.
+
+| URL Query  | Description |
+|------------|-------------|
+| `x-migrations-table`| Name of the migrations table |
+| `x-migrations-table-engine`| Engine to use for the migrations table, defaults to TinyLog |
+| `x-cluster-name` | Name of cluster for creating `schema_migrations` table cluster wide |
+| `x-multi-statement` | Enable multiple statements to be ran in a single migration (See note below) |
+| `x-multi-statement-max-size` | Maximum size of a single migration in bytes when `x-multi-statement` is set (defaults to 10 MB) |
+| `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. |
+
+## Notes
+
+* The Datastore driver does not natively support executing multiple 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.
+* Using the default TinyLog table engine for the `schema_migrations` table prevents backing up the table. If you need to back up the database, run the migrations with `x-migrations-table-engine=MergeTree`.
+* Datastore cluster mode is not officially supported, but you can try enabling `schema_migrations` table replication by specifying a `x-cluster-name`:
+  * When `x-cluster-name` is specified, `x-migrations-table-engine` also should be specified.
+  * When `x-cluster-name` is specified, only the `schema_migrations` table is replicated across the cluster. You still need to write your migrations so that the application tables are replicated within the cluster.
+* If you want to create a database inside a migration, note that the `schema_migrations` table will live in the `default` database, so you cannot use `USE <database_name>` inside a migration. In this case you may omit the database in the connection string (example [here](examples/migrations/003_create_database.up.sql)).
@@ -0,0 +1,337 @@
+// Package datastore implements the golang-migrate database.Driver interface for
+// Hanzo Datastore (a ClickHouse-wire-compatible database engine). It registers
+// the "datastore://" URL scheme and connects through the native
+// github.com/hanzo-ds/go driver, which registers the database/sql driver name
+// "datastore".
+//
+// Usage:
+//
+//	import _ "github.com/golang-migrate/migrate/v4/database/datastore"
+//
+// Then use a URL like:
+//
+//	datastore://host:9000?username=default&database=default&x-multi-statement=true
+package datastore
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/golang-migrate/migrate/v4/database/multistmt"
+
+	// Registers the "datastore" database/sql driver (ClickHouse-wire native).
+	_ "github.com/hanzo-ds/go"
+)
+
+var (
+	multiStmtDelimiter = []byte(";")
+
+	// DriverName is the database/sql driver registered by github.com/hanzo-ds/go.
+	DriverName = "datastore"
+
+	DefaultMigrationsTable       = "schema_migrations"
+	DefaultMigrationsTableEngine = "TinyLog"
+	DefaultMultiStatementMaxSize = 10 * 1 << 20 // 10 MB
+
+	ErrNilConfig = fmt.Errorf("no config")
+)
+
+type Config struct {
+	DatabaseName          string
+	ClusterName           string
+	MigrationsTable       string
+	MigrationsTableEngine string
+	MultiStatementEnabled bool
+	MultiStatementMaxSize int
+}
+
+func init() {
+	database.Register("datastore", &Datastore{})
+}
+
+// WithInstance creates a Datastore driver from an existing *sql.DB opened
+// against the "datastore" driver.
+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
+	}
+
+	ds := &Datastore{
+		conn:   conn,
+		config: config,
+	}
+
+	if err := ds.init(); err != nil {
+		return nil, err
+	}
+
+	return ds, nil
+}
+
+// Datastore is a golang-migrate database.Driver backed by the native
+// github.com/hanzo-ds/go ClickHouse-wire driver.
+type Datastore struct {
+	conn     *sql.DB
+	config   *Config
+	isLocked atomic.Bool
+}
+
+func (ds *Datastore) Open(dsn string) (database.Driver, error) {
+	purl, err := url.Parse(dsn)
+	if err != nil {
+		return nil, err
+	}
+	q := migrate.FilterCustomQuery(purl)
+	q.Scheme = DriverName
+	conn, err := sql.Open(DriverName, q.String())
+	if err != nil {
+		return nil, err
+	}
+
+	multiStatementMaxSize := DefaultMultiStatementMaxSize
+	if s := purl.Query().Get("x-multi-statement-max-size"); len(s) > 0 {
+		multiStatementMaxSize, err = strconv.Atoi(s)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	migrationsTableEngine := DefaultMigrationsTableEngine
+	if s := purl.Query().Get("x-migrations-table-engine"); len(s) > 0 {
+		migrationsTableEngine = s
+	}
+
+	ds = &Datastore{
+		conn: conn,
+		config: &Config{
+			MigrationsTable:       purl.Query().Get("x-migrations-table"),
+			MigrationsTableEngine: migrationsTableEngine,
+			DatabaseName:          purl.Query().Get("database"),
+			ClusterName:           purl.Query().Get("x-cluster-name"),
+			MultiStatementEnabled: purl.Query().Get("x-multi-statement") == "true",
+			MultiStatementMaxSize: multiStatementMaxSize,
+		},
+	}
+
+	if err := ds.init(); err != nil {
+		return nil, err
+	}
+
+	return ds, nil
+}
+
+func (ds *Datastore) init() error {
+	if len(ds.config.DatabaseName) == 0 {
+		if err := ds.conn.QueryRow("SELECT currentDatabase()").Scan(&ds.config.DatabaseName); err != nil {
+			return err
+		}
+	}
+
+	if len(ds.config.MigrationsTable) == 0 {
+		ds.config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	if ds.config.MultiStatementMaxSize <= 0 {
+		ds.config.MultiStatementMaxSize = DefaultMultiStatementMaxSize
+	}
+
+	if len(ds.config.MigrationsTableEngine) == 0 {
+		ds.config.MigrationsTableEngine = DefaultMigrationsTableEngine
+	}
+
+	return ds.ensureVersionTable()
+}
+
+func (ds *Datastore) Run(r io.Reader) error {
+	if ds.config.MultiStatementEnabled {
+		var err error
+		if e := multistmt.Parse(r, multiStmtDelimiter, ds.config.MultiStatementMaxSize, func(m []byte) bool {
+			tq := strings.TrimSpace(string(m))
+			if tq == "" {
+				return true
+			}
+			if _, e := ds.conn.Exec(string(m)); e != nil {
+				err = database.Error{OrigErr: e, Err: "migration failed", Query: m}
+				return false
+			}
+			return true
+		}); e != nil {
+			return e
+		}
+		return err
+	}
+
+	migration, err := io.ReadAll(r)
+	if err != nil {
+		return err
+	}
+
+	if _, err := ds.conn.Exec(string(migration)); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migration}
+	}
+
+	return nil
+}
+
+func (ds *Datastore) Version() (int, bool, error) {
+	var (
+		version int
+		dirty   uint8
+		query   = "SELECT version, dirty FROM `" + ds.config.MigrationsTable + "` ORDER BY sequence DESC LIMIT 1"
+	)
+	if err := ds.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 (ds *Datastore) SetVersion(version int, dirty bool) error {
+	var (
+		bool = func(v bool) uint8 {
+			if v {
+				return 1
+			}
+			return 0
+		}
+		tx, err = ds.conn.Begin()
+	)
+	if err != nil {
+		return err
+	}
+
+	query := "INSERT INTO " + ds.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()
+}
+
+// ensureVersionTable checks if versions table exists and, if not, creates it.
+// Note that this function locks the database, which deviates from the usual
+// convention of "caller locks" in the Datastore type.
+func (ds *Datastore) ensureVersionTable() (err error) {
+	if err = ds.Lock(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if e := ds.Unlock(); e != nil {
+			err = errors.Join(err, e)
+		}
+	}()
+
+	var (
+		table string
+		query = "SHOW TABLES FROM " + quoteIdentifier(ds.config.DatabaseName) + " LIKE '" + ds.config.MigrationsTable + "'"
+	)
+	// check if migration table exists
+	if err := ds.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
+	if len(ds.config.ClusterName) > 0 {
+		query = fmt.Sprintf(`
+			CREATE TABLE %s ON CLUSTER %s (
+				version    Int64,
+				dirty      UInt8,
+				sequence   UInt64
+			) Engine=%s`, ds.config.MigrationsTable, ds.config.ClusterName, ds.config.MigrationsTableEngine)
+	} else {
+		query = fmt.Sprintf(`
+			CREATE TABLE %s (
+				version    Int64,
+				dirty      UInt8,
+				sequence   UInt64
+			) Engine=%s`, ds.config.MigrationsTable, ds.config.MigrationsTableEngine)
+	}
+
+	if strings.HasSuffix(ds.config.MigrationsTableEngine, "Tree") {
+		query = fmt.Sprintf(`%s ORDER BY sequence`, query)
+	}
+
+	if _, err := ds.conn.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+func (ds *Datastore) Drop() (err error) {
+	query := "SHOW TABLES FROM " + quoteIdentifier(ds.config.DatabaseName)
+	tables, err := ds.conn.Query(query)
+
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer func() {
+		if errClose := tables.Close(); errClose != nil {
+			err = errors.Join(err, errClose)
+		}
+	}()
+
+	for tables.Next() {
+		var table string
+		if err := tables.Scan(&table); err != nil {
+			return err
+		}
+
+		query = "DROP TABLE IF EXISTS " + quoteIdentifier(ds.config.DatabaseName) + "." + quoteIdentifier(table)
+
+		if _, err := ds.conn.Exec(query); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+func (ds *Datastore) Lock() error {
+	if !ds.isLocked.CompareAndSwap(false, true) {
+		return database.ErrLocked
+	}
+
+	return nil
+}
+
+func (ds *Datastore) Unlock() error {
+	if !ds.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
+
+	return nil
+}
+
+func (ds *Datastore) Close() error { return ds.conn.Close() }
+
+// Copied from lib/pq implementation: https://github.com/lib/pq/blob/v1.9.0/conn.go#L1611
+func quoteIdentifier(name string) string {
+	end := strings.IndexRune(name, 0)
+	if end > -1 {
+		name = name[:end]
+	}
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
+}
@@ -0,0 +1,226 @@
+package datastore_test
+
+import (
+	"context"
+	"database/sql"
+	sqldriver "database/sql/driver"
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/dhui/dktest"
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database/datastore"
+	dt "github.com/golang-migrate/migrate/v4/database/testing"
+	"github.com/golang-migrate/migrate/v4/dktesting"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+
+	// Registers the "datastore" database/sql driver (ClickHouse-wire native).
+	_ "github.com/hanzo-ds/go"
+)
+
+const defaultPort = 9000
+
+var (
+	tableEngines = []string{"TinyLog", "MergeTree"}
+	opts         = dktest.Options{
+		Env:          map[string]string{"CLICKHOUSE_USER": "user", "CLICKHOUSE_PASSWORD": "password", "CLICKHOUSE_DB": "db"},
+		PortRequired: true, ReadyFunc: isReady,
+	}
+	specs = []dktesting.ContainerSpec{
+		{ImageName: "clickhouse:24.8", Options: opts},
+	}
+)
+
+func datastoreConnectionString(host, port, engine string) string {
+	if engine != "" {
+		return fmt.Sprintf(
+			"datastore://%v:%v?username=user&password=password&database=db&x-multi-statement=true&x-migrations-table-engine=%v&debug=false",
+			host, port, engine)
+	}
+
+	return fmt.Sprintf(
+		"datastore://%v:%v?username=user&password=password&database=db&x-multi-statement=true&debug=false",
+		host, port)
+}
+
+func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
+	ip, port, err := c.Port(defaultPort)
+	if err != nil {
+		return false
+	}
+
+	db, err := sql.Open("datastore", datastoreConnectionString(ip, port, ""))
+
+	if err != nil {
+		log.Println("open error", err)
+		return false
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			log.Println("close error:", err)
+		}
+	}()
+
+	if err = db.PingContext(ctx); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn:
+			return false
+		default:
+			fmt.Println(err)
+		}
+		return false
+	}
+
+	return true
+}
+
+func TestCases(t *testing.T) {
+	for _, engine := range tableEngines {
+		t.Run("Test_"+engine, func(t *testing.T) { testSimple(t, engine) })
+		t.Run("Migrate_"+engine, func(t *testing.T) { testMigrate(t, engine) })
+		t.Run("Version_"+engine, func(t *testing.T) { testVersion(t, engine) })
+		t.Run("Drop_"+engine, func(t *testing.T) { testDrop(t, engine) })
+	}
+	t.Run("WithInstanceDefaultConfigValues", func(t *testing.T) { testSimpleWithInstanceDefaultConfigValues(t) })
+}
+
+func testSimple(t *testing.T, engine string) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := datastoreConnectionString(ip, port, engine)
+		p := &datastore.Datastore{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		dt.Test(t, d, []byte("SELECT 1"))
+	})
+}
+
+func testSimpleWithInstanceDefaultConfigValues(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := datastoreConnectionString(ip, port, "")
+		conn, err := sql.Open("datastore", addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		d, err := datastore.WithInstance(conn, &datastore.Config{})
+		if err != nil {
+			_ = conn.Close()
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		dt.Test(t, d, []byte("SELECT 1"))
+	})
+}
+
+func testMigrate(t *testing.T, engine string) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := datastoreConnectionString(ip, port, engine)
+		p := &datastore.Datastore{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "db", d)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+	})
+}
+
+func testVersion(t *testing.T, engine string) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		expectedVersion := 1
+
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := datastoreConnectionString(ip, port, engine)
+		p := &datastore.Datastore{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		err = d.SetVersion(expectedVersion, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		version, _, err := d.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if version != expectedVersion {
+			t.Fatal("Version mismatch")
+		}
+	})
+}
+
+func testDrop(t *testing.T, engine string) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := datastoreConnectionString(ip, port, engine)
+		p := &datastore.Datastore{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		err = d.Drop()
+		if err != nil {
+			t.Fatal(err)
+		}
+	})
+}
@@ -1,3 +1,3 @@
 CREATE TABLE test_1 (
-    Date Date 
+    Date Date
 ) Engine=Memory;
@@ -1,3 +1,3 @@
 CREATE TABLE test_2 (
-    Date Date 
+    Date Date
 ) Engine=Memory;
@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS driver_ratings;
+DROP TABLE IF EXISTS user_ratings;
+DROP TABLE IF EXISTS orders;
+DROP TABLE IF EXISTS driver_ratings_queue;
+DROP TABLE IF EXISTS user_ratings_queue;
+DROP TABLE IF EXISTS orders_queue;
+DROP VIEW IF EXISTS user_ratings_queue_mv;
+DROP VIEW IF EXISTS driver_ratings_queue_mv;
+DROP VIEW IF EXISTS orders_queue_mv;
+DROP DATABASE IF EXISTS analytics;
@@ -0,0 +1,81 @@
+CREATE DATABASE IF NOT EXISTS analytics;
+
+CREATE TABLE IF NOT EXISTS analytics.driver_ratings(
+    rate UInt8,
+    userID Int64,
+    driverID String,
+    orderID String,
+    inserted_time DateTime DEFAULT now()
+) ENGINE = MergeTree
+PARTITION BY driverID
+ORDER BY (inserted_time);
+
+CREATE TABLE analytics.driver_ratings_queue(
+    rate UInt8,
+    userID Int64,
+    driverID String,
+    orderID String
+) ENGINE = Kafka
+SETTINGS kafka_broker_list = 'broker:9092',
+    kafka_topic_list = 'driver-ratings',
+    kafka_group_name = 'rating_readers',
+    kafka_format = 'Avro',
+    kafka_max_block_size = 1048576;
+
+CREATE MATERIALIZED VIEW analytics.driver_ratings_queue_mv TO analytics.driver_ratings AS
+SELECT rate, userID, driverID, orderID
+FROM analytics.driver_ratings_queue;
+
+CREATE TABLE IF NOT EXISTS analytics.user_ratings(
+    rate UInt8,
+    userID Int64,
+    driverID String,
+    orderID String,
+    inserted_time DateTime DEFAULT now()
+) ENGINE = MergeTree
+    PARTITION BY userID
+    ORDER BY (inserted_time);
+
+CREATE TABLE analytics.user_ratings_queue(
+    rate UInt8,
+    userID Int64,
+    driverID String,
+    orderID String
+) ENGINE = Kafka
+SETTINGS kafka_broker_list = 'broker:9092',
+    kafka_topic_list = 'user-ratings',
+    kafka_group_name = 'rating_readers',
+    kafka_format = 'JSON',
+    kafka_max_block_size = 1048576;
+
+CREATE MATERIALIZED VIEW analytics.user_ratings_queue_mv TO analytics.user_ratings AS
+SELECT rate, userID, driverID, orderID
+FROM analytics.user_ratings_queue;
+
+CREATE TABLE IF NOT EXISTS analytics.orders(
+    from_place String,
+    to_place String,
+    userID Int64,
+    driverID String,
+    orderID String,
+    inserted_time DateTime DEFAULT now()
+) ENGINE = MergeTree
+    PARTITION BY driverID
+    ORDER BY (inserted_time);
+
+CREATE TABLE analytics.orders_queue(
+    from_place String,
+    to_place String,
+    userID Int64,
+    driverID String,
+    orderID String
+) ENGINE = Kafka
+SETTINGS kafka_broker_list = 'broker:9092',
+    kafka_topic_list = 'orders',
+    kafka_group_name = 'order_readers',
+    kafka_format = 'Avro',
+    kafka_max_block_size = 1048576;
+
+CREATE MATERIALIZED VIEW analytics.orders_queue_mv TO orders AS
+SELECT from_place, to_place, userID, driverID, orderID
+FROM analytics.orders_queue;
@@ -1,4 +1,4 @@
-// Package database provides the Database interface.
+// Package database provides the Driver interface.
 // All database drivers must implement this interface, register themselves,
 // optionally provide a `WithInstance` function and pass the tests
 // in package database/testing.
@@ -25,22 +25,22 @@ var drivers = make(map[string]Driver)
 // Driver is the interface every database driver must implement.
 //
 // How to implement a database driver?
-//   1. Implement this interface.
-//   2. Optionally, add a function named `WithInstance`.
-//      This function should accept an existing DB instance and a Config{} struct
-//      and return a driver instance.
-//   3. Add a test that calls database/testing.go:Test()
-//   4. Add own tests for Open(), WithInstance() (when provided) and Close().
-//      All other functions are tested by tests in database/testing.
-//      Saves you some time and makes sure all database drivers behave the same way.
-//   5. Call Register in init().
-//   6. Create a internal/cli/build_<driver-name>.go file
-//   7. Add driver name in 'DATABASE' variable in Makefile
+//  1. Implement this interface.
+//  2. Optionally, add a function named `WithInstance`.
+//     This function should accept an existing DB instance and a Config{} struct
+//     and return a driver instance.
+//  3. Add a test that calls database/testing.go:Test()
+//  4. Add own tests for Open(), WithInstance() (when provided) and Close().
+//     All other functions are tested by tests in database/testing.
+//     Saves you some time and makes sure all database drivers behave the same way.
+//  5. Call Register in init().
+//  6. Create a internal/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.
+//   - Don't try to correct user input. Don't assume things.
 //     When in doubt, return an error and explain the situation to the user.
-//   * All configuration input must come from the URL string in func Open()
+//   - All configuration input must come from the URL string in func Open()
 //     or the Config{} struct in WithInstance. Don't os.Getenv().
 type Driver interface {
 	// Open returns a new driver instance configured with parameters
@@ -1,18 +1,19 @@
-// +build go1.9
+//go:build go1.9

 package firebird

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
+	"io"
+	nurl "net/url"
+	"sync/atomic"
+
 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	_ "github.com/nakagami/firebirdsql"
-	"io"
-	"io/ioutil"
-	nurl "net/url"
 )

 func init() {
@@ -36,7 +37,7 @@ type Firebird struct {
 	// Locking and unlocking need to use the same connection
 	conn     *sql.Conn
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	// Open and WithInstance need to guarantee that config is never nil
 	config *Config
@@ -106,20 +107,21 @@ func (f *Firebird) Close() error {
 }

 func (f *Firebird) Lock() error {
-	if f.isLocked {
+	if !f.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	f.isLocked = true
 	return nil
 }

 func (f *Firebird) Unlock() error {
-	f.isLocked = false
+	if !f.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
 	return nil
 }

 func (f *Firebird) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -178,7 +180,7 @@ func (f *Firebird) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -193,6 +195,9 @@ func (f *Firebird) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	// delete one by one ...
 	for _, t := range tableNames {
@@ -218,11 +223,7 @@ func (f *Firebird) ensureVersionTable() (err error) {

 	defer func() {
 		if e := f.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -38,8 +38,9 @@ var (
 		},
 	}
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "jacobalberty/firebird:2.5-ss", Options: opts},
-		{ImageName: "jacobalberty/firebird:3.0", Options: opts},
+		{ImageName: "jacobalberty/firebird:v3.0", Options: opts},
+		{ImageName: "jacobalberty/firebird:v4.0", Options: opts},
+		{ImageName: "jacobalberty/firebird:v5.0", Options: opts},
 	}
 )

@@ -15,8 +15,8 @@
 | `x-transaction-mode` | `TransactionMode` | If set to `true` wrap commands in [transaction](https://docs.mongodb.com/manual/core/transactions). Available only for replica set. Driver is using [strconv.ParseBool](https://golang.org/pkg/strconv/#ParseBool) for parsing|
 | `x-advisory-locking` | `true` | Feature flag for advisory locking, if set to false, disable advisory locking |
 | `x-advisory-lock-collection` | `migrate_advisory_lock` | The name of the collection to use for advisory locking.|
-| `x-advisory-lock-timout` | `15` | The max time in seconds that the advisory lock will wait if the db is already locked. |
-| `x-advisory-lock-timout-interval` | `10` | The max timeout in seconds interval that the advisory lock will wait if the db is already locked. |
+| `x-advisory-lock-timeout` | `15` | The max time in seconds that migrate will wait to acquire a lock before failing. |
+| `x-advisory-lock-timeout-interval` | `10` | The max time in seconds between attempts to acquire the advisory lock, the lock is attempted to be acquired using an exponential backoff algorithm. |
 | `dbname` | `DatabaseName` | The name of the database to connect to |
 | `user` | | The user to sign in as. Can be omitted |
 | `password` | | The user's password. Can be omitted | 
@@ -2,20 +2,21 @@ package mongodb

 import (
 	"context"
+	"errors"
 	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"strconv"
+	"sync/atomic"
+	"time"
+
 	"github.com/cenkalti/backoff/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/x/mongo/driver/connstring"
-	"io"
-	"io/ioutil"
-	"net/url"
-	os "os"
-	"strconv"
-	"time"
 )

 func init() {
@@ -35,14 +36,16 @@ const LockIndexName = "lock_unique_key"                  // the name of the inde
 const contextWaitTimeout = 5 * time.Second               // how long to wait for the request to mongo to block/wait for.

 var (
-	ErrNoDatabaseName = fmt.Errorf("no database name")
-	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName            = fmt.Errorf("no database name")
+	ErrNilConfig                 = fmt.Errorf("no config")
+	ErrLockTimeoutConfigConflict = fmt.Errorf("both x-advisory-lock-timeout-interval and x-advisory-lock-timout-interval were specified")
 )

 type Mongo struct {
-	client *mongo.Client
-	db     *mongo.Database
-	config *Config
+	client   *mongo.Client
+	db       *mongo.Database
+	config   *Config
+	isLocked atomic.Bool
 }

 type Locking struct {
@@ -111,7 +114,7 @@ func WithInstance(instance *mongo.Client, config *Config) (database.Driver, erro
 }

 func (m *Mongo) Open(dsn string) (database.Driver, error) {
-	//connstring is experimental package, but it used for parse connection string in mongo.Connect function
+	// connstring is experimental package, but it used for parse connection string in mongo.Connect function
 	uri, err := connstring.Parse(dsn)
 	if err != nil {
 		return nil, err
@@ -135,7 +138,22 @@ func (m *Mongo) Open(dsn string) (database.Driver, error) {
 	if err != nil {
 		return nil, err
 	}
-	maxLockingIntervals, err := parseInt(unknown.Get("x-advisory-lock-timout-interval"), DefaultLockTimeoutInterval)
+
+	lockTimeoutIntervalValue := unknown.Get("x-advisory-lock-timeout-interval")
+	// The initial release had a typo for this argument but for backwards compatibility sake, we will keep supporting it
+	// and we will error out if both values are set.
+	lockTimeoutIntervalValueFromTypo := unknown.Get("x-advisory-lock-timout-interval")
+
+	lockTimeout := lockTimeoutIntervalValue
+
+	if lockTimeoutIntervalValue != "" && lockTimeoutIntervalValueFromTypo != "" {
+		return nil, ErrLockTimeoutConfigConflict
+	} else if lockTimeoutIntervalValueFromTypo != "" {
+		lockTimeout = lockTimeoutIntervalValueFromTypo
+	}
+
+	maxLockCheckInterval, err := parseInt(lockTimeout, DefaultLockTimeoutInterval)
+
 	if err != nil {
 		return nil, err
 	}
@@ -155,7 +173,7 @@ func (m *Mongo) Open(dsn string) (database.Driver, error) {
 			CollectionName: lockCollection,
 			Timeout:        lockingTimout,
 			Enabled:        advisoryLockingFlag,
-			Interval:       maxLockingIntervals,
+			Interval:       maxLockCheckInterval,
 		},
 	})
 	if err != nil {
@@ -164,7 +182,7 @@ func (m *Mongo) Open(dsn string) (database.Driver, error) {
 	return mc, nil
 }

-//Parse the url param, convert it to boolean
+// Parse the url param, convert it to boolean
 // returns error if param invalid. returns defaultValue if param not present
 func parseBoolean(urlParam string, defaultValue bool) (bool, error) {

@@ -181,7 +199,7 @@ func parseBoolean(urlParam string, defaultValue bool) (bool, error) {
 	return defaultValue, nil
 }

-//Parse the url param, convert it to int
+// Parse the url param, convert it to int
 // returns error if param invalid. returns defaultValue if param not present
 func parseInt(urlParam string, defaultValue int) (int, error) {

@@ -223,7 +241,7 @@ func (m *Mongo) Version() (version int, dirty bool, err error) {
 }

 func (m *Mongo) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -250,8 +268,8 @@ func (m *Mongo) executeCommandsWithTransaction(ctx context.Context, cmds []bson.
 			return &database.Error{OrigErr: err, Err: "failed to start transaction"}
 		}
 		if err := m.executeCommands(sessionContext, cmds); err != nil {
-			//When command execution is failed, it's aborting transaction
-			//If you tried to call abortTransaction, it`s return error that transaction already aborted
+			// When command execution is failed, it's aborting transaction
+			// If you tried to call abortTransaction, it`s return error that transaction already aborted
 			return err
 		}
 		if err := sessionContext.CommitTransaction(sessionContext); err != nil {
@@ -307,11 +325,7 @@ func (m *Mongo) ensureVersionTable() (err error) {

 	defer func() {
 		if e := m.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -327,55 +341,60 @@ func (m *Mongo) ensureVersionTable() (err error) {
 // Utilizes advisory locking on the config.LockingCollection collection
 // This uses a unique index on the `locking_key` field.
 func (m *Mongo) Lock() error {
-	if !m.config.Locking.Enabled {
+	return database.CasRestoreOnErr(&m.isLocked, false, true, database.ErrLocked, func() error {
+		if !m.config.Locking.Enabled {
+			return nil
+		}
+
+		pid := os.Getpid()
+		hostname, err := os.Hostname()
+		if err != nil {
+			hostname = fmt.Sprintf("Could not determine hostname. Error: %s", err.Error())
+		}
+
+		newLockObj := lockObj{
+			Key:       lockKeyUniqueValue,
+			Pid:       pid,
+			Hostname:  hostname,
+			CreatedAt: time.Now(),
+		}
+		operation := func() error {
+			timeout, cancelFunc := context.WithTimeout(context.Background(), contextWaitTimeout)
+			_, err := m.db.Collection(m.config.Locking.CollectionName).InsertOne(timeout, newLockObj)
+			defer cancelFunc()
+			return err
+		}
+		exponentialBackOff := backoff.NewExponentialBackOff()
+		duration := time.Duration(m.config.Locking.Timeout) * time.Second
+		exponentialBackOff.MaxElapsedTime = duration
+		exponentialBackOff.MaxInterval = time.Duration(m.config.Locking.Interval) * time.Second
+
+		err = backoff.Retry(operation, exponentialBackOff)
+		if err != nil {
+			return database.ErrLocked
+		}
+
 		return nil
-	}
-	pid := os.Getpid()
-	hostname, err := os.Hostname()
-	if err != nil {
-		hostname = fmt.Sprintf("Could not determine hostname. Error: %s", err.Error())
-	}
-
-	newLockObj := lockObj{
-		Key:       lockKeyUniqueValue,
-		Pid:       pid,
-		Hostname:  hostname,
-		CreatedAt: time.Now(),
-	}
-	operation := func() error {
-		timeout, cancelFunc := context.WithTimeout(context.Background(), contextWaitTimeout)
-		_, err := m.db.Collection(m.config.Locking.CollectionName).InsertOne(timeout, newLockObj)
-		defer cancelFunc()
-		return err
-	}
-	exponentialBackOff := backoff.NewExponentialBackOff()
-	duration := time.Duration(m.config.Locking.Timeout) * time.Second
-	exponentialBackOff.MaxElapsedTime = duration
-	exponentialBackOff.MaxInterval = time.Duration(m.config.Locking.Interval) * time.Second
-
-	err = backoff.Retry(operation, exponentialBackOff)
-	if err != nil {
-		return database.ErrLocked
-	}
-
-	return nil
-
+	})
 }
+
 func (m *Mongo) Unlock() error {
-	if !m.config.Locking.Enabled {
+	return database.CasRestoreOnErr(&m.isLocked, true, false, database.ErrNotLocked, func() error {
+		if !m.config.Locking.Enabled {
+			return nil
+		}
+
+		filter := findFilter{
+			Key: lockKeyUniqueValue,
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), contextWaitTimeout)
+		_, err := m.db.Collection(m.config.Locking.CollectionName).DeleteMany(ctx, filter)
+		defer cancel()
+
+		if err != nil {
+			return err
+		}
 		return nil
-	}
-
-	filter := findFilter{
-		Key: lockKeyUniqueValue,
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), contextWaitTimeout)
-	_, err := m.db.Collection(m.config.Locking.CollectionName).DeleteMany(ctx, filter)
-	defer cancel()
-
-	if err != nil {
-		return err
-	}
-	return nil
+	})
 }
@@ -32,10 +32,10 @@ var (
 	opts = dktest.Options{PortRequired: true, ReadyFunc: isReady}
 	// Supported versions: https://www.mongodb.com/support-policy
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "mongo:3.4", Options: opts},
-		{ImageName: "mongo:3.6", Options: opts},
-		{ImageName: "mongo:4.0", Options: opts},
-		{ImageName: "mongo:4.2", Options: opts},
+		{ImageName: "mongo:5.0", Options: opts},
+		{ImageName: "mongo:6.0", Options: opts},
+		{ImageName: "mongo:7.0", Options: opts},
+		{ImageName: "mongo:8.0", Options: opts},
 	}
 )

@@ -74,6 +74,22 @@ func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
 }

 func Test(t *testing.T) {
+	t.Run("test", test)
+	t.Run("testMigrate", testMigrate)
+	t.Run("testWithAuth", testWithAuth)
+	t.Run("testLockWorks", testLockWorks)
+
+	t.Cleanup(func() {
+		for _, spec := range specs {
+			t.Log("Cleaning up ", spec.ImageName)
+			if err := spec.Cleanup(); err != nil {
+				t.Error("Error removing ", spec.ImageName, "error:", err)
+			}
+		}
+	})
+}
+
+func test(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -99,7 +115,7 @@ func Test(t *testing.T) {
 	})
 }

-func TestMigrate(t *testing.T) {
+func testMigrate(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -125,7 +141,7 @@ func TestMigrate(t *testing.T) {
 	})
 }

-func TestWithAuth(t *testing.T) {
+func testWithAuth(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -180,7 +196,7 @@ func TestWithAuth(t *testing.T) {
 	})
 }

-func TestLockWorks(t *testing.T) {
+func testLockWorks(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -221,18 +237,7 @@ func TestLockWorks(t *testing.T) {
 			t.Fatal(err)
 		}

-		// disable locking, validate wer can lock twice
-		mc.config.Locking.Enabled = false
-		err = mc.Lock()
-		if err != nil {
-			t.Fatal(err)
-		}
-		err = mc.Lock()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		// re-enable locking,
+		// enable locking,
 		//try to hit a lock conflict
 		mc.config.Locking.Enabled = true
 		mc.config.Locking.Timeout = 1
@@ -252,6 +257,15 @@ func TestTransaction(t *testing.T) {
 		{ImageName: "mongo:4", Options: dktest.Options{PortRequired: true, ReadyFunc: isReady,
 			Cmd: []string{"mongod", "--bind_ip_all", "--replSet", "rs0"}}},
 	}
+	t.Cleanup(func() {
+		for _, spec := range transactionSpecs {
+			t.Log("Cleaning up ", spec.ImageName)
+			if err := spec.Cleanup(); err != nil {
+				t.Error("Error removing ", spec.ImageName, "error:", err)
+			}
+		}
+	})
+
 	dktesting.ParallelTest(t, transactionSpecs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -6,6 +6,7 @@
 |------------|---------------------|-------------|
 | `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
 | `x-no-lock` | `NoLock` | Set to `true` to skip `GET_LOCK`/`RELEASE_LOCK` statements. Useful for [multi-master MySQL flavors](https://www.percona.com/doc/percona-xtradb-cluster/LATEST/features/pxc-strict-mode.html#explicit-table-locking). Only run migrations from one host when this is enabled. |
+| `x-statement-timeout` | `StatementTimeout` | Abort any statement that takes more than the specified number of milliseconds, functionally similar to [Server-side SELECT statement timeouts](https://dev.mysql.com/blog-archive/server-side-select-statement-timeouts/) but enforced by the client. Available for all versions of MySQL, not just >=5.7. | 
 | `dbname` | `DatabaseName` | The name of the database to connect to |
 | `user` | | The user to sign in as |
 | `password` | | The user's password | 
@@ -13,7 +14,7 @@
 | `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-cert` | | The location of the client certificate 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) | 

@@ -28,9 +29,9 @@ 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"
+    "github.com/golang-migrate/migrate/v4"
+    "github.com/golang-migrate/migrate/v4/database/mysql"
+    _ "github.com/golang-migrate/migrate/v4/source/file"
 )

 func main() {
@@ -1,4 +1,4 @@
-// +build go1.9
+//go:build go1.9

 package mysql

@@ -7,23 +7,22 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
+	"os"
 	"strconv"
 	"strings"
-)
+	"sync/atomic"
+	"time"

-import (
 	"github.com/go-sql-driver/mysql"
-	"github.com/hashicorp/go-multierror"
-)
-
-import (
 	"github.com/golang-migrate/migrate/v4/database"
 )

+var _ database.Driver = (*Mysql)(nil) // explicit compile time type check
+
 func init() {
 	database.Register("mysql", &Mysql{})
 }
@@ -35,13 +34,14 @@ 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")
+	ErrTLSCertKeyConfig = fmt.Errorf("to use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")
 )

 type Config struct {
-	MigrationsTable string
-	DatabaseName    string
-	NoLock          bool
+	MigrationsTable  string
+	DatabaseName     string
+	NoLock           bool
+	StatementTimeout time.Duration
 }

 type Mysql struct {
@@ -49,25 +49,31 @@ type Mysql struct {
 	// just do everything over a single conn anyway.
 	conn     *sql.Conn
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	config *Config
 }

-// instance must have `multiStatements` set to true
-func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+// connection instance must have `multiStatements` set to true
+func WithConnection(ctx context.Context, conn *sql.Conn, config *Config) (*Mysql, error) {
 	if config == nil {
 		return nil, ErrNilConfig
 	}

-	if err := instance.Ping(); err != nil {
+	if err := conn.PingContext(ctx); err != nil {
 		return nil, err
 	}

+	mx := &Mysql{
+		conn:   conn,
+		db:     nil,
+		config: config,
+	}
+
 	if config.DatabaseName == "" {
 		query := `SELECT DATABASE()`
 		var databaseName sql.NullString
-		if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		if err := conn.QueryRowContext(ctx, query).Scan(&databaseName); err != nil {
 			return nil, &database.Error{OrigErr: err, Query: []byte(query)}
 		}

@@ -82,21 +88,33 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
 		config.MigrationsTable = DefaultMigrationsTable
 	}

-	conn, err := instance.Conn(context.Background())
+	if err := mx.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return mx, nil
+}
+
+// instance must have `multiStatements` set to true
+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	ctx := context.Background()
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+
+	conn, err := instance.Conn(ctx)
 	if err != nil {
 		return nil, err
 	}

-	mx := &Mysql{
-		conn:   conn,
-		db:     instance,
-		config: config,
-	}
-
-	if err := mx.ensureVersionTable(); err != nil {
+	mx, err := WithConnection(ctx, conn, config)
+	if err != nil {
 		return nil, err
 	}

+	mx.db = instance
+
 	return mx, nil
 }

@@ -118,6 +136,68 @@ func extractCustomQueryParams(c *mysql.Config) (map[string]string, error) {
 }

 func urlToMySQLConfig(url string) (*mysql.Config, error) {
+	// Need to parse out custom TLS parameters and call
+	// mysql.RegisterTLSConfig() before mysql.ParseDSN() is called
+	// which consumes the registered tls.Config
+	// Fixes: https://github.com/golang-migrate/migrate/issues/411
+	//
+	// Can't use url.Parse() since it fails to parse MySQL DSNs
+	// mysql.ParseDSN() also searches for "?" to find query parameters:
+	// https://github.com/go-sql-driver/mysql/blob/46351a8/dsn.go#L344
+	if idx := strings.LastIndex(url, "?"); idx > 0 {
+		rawParams := url[idx+1:]
+		parsedParams, err := nurl.ParseQuery(rawParams)
+		if err != nil {
+			return nil, err
+		}
+
+		ctls := parsedParams.Get("tls")
+		if len(ctls) > 0 {
+			if _, isBool := readBool(ctls); !isBool && strings.ToLower(ctls) != "skip-verify" {
+				rootCertPool := x509.NewCertPool()
+				pem, err := os.ReadFile(parsedParams.Get("x-tls-ca"))
+				if err != nil {
+					return nil, err
+				}
+
+				if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
+					return nil, ErrAppendPEM
+				}
+
+				clientCert := make([]tls.Certificate, 0, 1)
+				if ccert, ckey := parsedParams.Get("x-tls-cert"), parsedParams.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
+				insecureSkipVerifyStr := parsedParams.Get("x-tls-insecure-skip-verify")
+				if len(insecureSkipVerifyStr) > 0 {
+					x, err := strconv.ParseBool(insecureSkipVerifyStr)
+					if err != nil {
+						return nil, err
+					}
+					insecureSkipVerify = x
+				}
+
+				err = mysql.RegisterTLSConfig(ctls, &tls.Config{
+					RootCAs:            rootCertPool,
+					Certificates:       clientCert,
+					InsecureSkipVerify: insecureSkipVerify,
+				})
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
 	config, err := mysql.ParseDSN(strings.TrimPrefix(url, "mysql://"))
 	if err != nil {
 		return nil, err
@@ -140,52 +220,6 @@ func urlToMySQLConfig(url string) (*mysql.Config, error) {
 	}
 	config.Passwd = password

-	// use custom TLS?
-	ctls := config.TLSConfig
-	if len(ctls) > 0 {
-		if _, isBool := readBool(ctls); !isBool && strings.ToLower(ctls) != "skip-verify" {
-			rootCertPool := x509.NewCertPool()
-			pem, err := ioutil.ReadFile(config.Params["x-tls-ca"])
-			if err != nil {
-				return nil, err
-			}
-
-			if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
-				return nil, ErrAppendPEM
-			}
-
-			clientCert := make([]tls.Certificate, 0, 1)
-			if ccert, ckey := config.Params["x-tls-cert"], config.Params["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
-			if len(config.Params["x-tls-insecure-skip-verify"]) > 0 {
-				x, err := strconv.ParseBool(config.Params["x-tls-insecure-skip-verify"])
-				if err != nil {
-					return nil, err
-				}
-				insecureSkipVerify = x
-			}
-
-			err = mysql.RegisterTLSConfig(ctls, &tls.Config{
-				RootCAs:            rootCertPool,
-				Certificates:       clientCert,
-				InsecureSkipVerify: insecureSkipVerify,
-			})
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
 	return config, nil
 }

@@ -208,15 +242,25 @@ func (m *Mysql) Open(url string) (database.Driver, error) {
 		}
 	}

+	statementTimeoutParam := customParams["x-statement-timeout"]
+	statementTimeout := 0
+	if statementTimeoutParam != "" {
+		statementTimeout, err = strconv.Atoi(statementTimeoutParam)
+		if err != nil {
+			return nil, fmt.Errorf("could not parse x-statement-timeout as float: %w", err)
+		}
+	}
+
 	db, err := sql.Open("mysql", config.FormatDSN())
 	if err != nil {
 		return nil, err
 	}

 	mx, err := WithInstance(db, &Config{
-		DatabaseName:    config.DBName,
-		MigrationsTable: customParams["x-migrations-table"],
-		NoLock:          noLock,
+		DatabaseName:     config.DBName,
+		MigrationsTable:  customParams["x-migrations-table"],
+		NoLock:           noLock,
+		StatementTimeout: time.Duration(statementTimeout) * time.Millisecond,
 	})
 	if err != nil {
 		return nil, err
@@ -227,7 +271,11 @@ func (m *Mysql) Open(url string) (database.Driver, error) {

 func (m *Mysql) Close() error {
 	connErr := m.conn.Close()
-	dbErr := m.db.Close()
+	var dbErr error
+	if m.db != nil {
+		dbErr = m.db.Close()
+	}
+
 	if connErr != nil || dbErr != nil {
 		return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)
 	}
@@ -235,72 +283,70 @@ func (m *Mysql) Close() error {
 }

 func (m *Mysql) Lock() error {
-	if m.isLocked {
-		return database.ErrLocked
-	}
+	return database.CasRestoreOnErr(&m.isLocked, false, true, database.ErrLocked, func() error {
+		if m.config.NoLock {
+			return nil
+		}
+		aid, err := database.GenerateAdvisoryLockId(
+			fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
+		if err != nil {
+			return err
+		}
+
+		query := "SELECT GET_LOCK(?, 10)"
+		var success bool
+		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)}
+		}
+
+		if !success {
+			return database.ErrLocked
+		}

-	if m.config.NoLock {
-		m.isLocked = true
 		return nil
-	}
-
-	aid, err := database.GenerateAdvisoryLockId(
-		fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
-	if err != nil {
-		return err
-	}
-
-	query := "SELECT GET_LOCK(?, 10)"
-	var success bool
-	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)}
-	}
-
-	if success {
-		m.isLocked = true
-		return nil
-	}
-
-	return database.ErrLocked
+	})
 }

 func (m *Mysql) Unlock() error {
-	if !m.isLocked {
+	return database.CasRestoreOnErr(&m.isLocked, true, false, database.ErrNotLocked, func() error {
+		if m.config.NoLock {
+			return nil
+		}
+
+		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.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.
+
 		return nil
-	}
-
-	if m.config.NoLock {
-		m.isLocked = false
-		return nil
-	}
-
-	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.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
+	})
 }

 func (m *Mysql) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}

+	ctx := context.Background()
+	if m.config.StatementTimeout != 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, m.config.StatementTimeout)
+		defer cancel()
+	}
+
 	query := string(migr[:])
-	if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
+	if _, err := m.conn.ExecContext(ctx, query); err != nil {
 		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
 	}

@@ -308,15 +354,15 @@ func (m *Mysql) Run(migration io.Reader) error {
 }

 func (m *Mysql) SetVersion(version int, dirty bool) error {
-	tx, err := m.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	tx, err := m.conn.BeginTx(context.Background(), &sql.TxOptions{Isolation: sql.LevelSerializable})
 	if err != nil {
 		return &database.Error{OrigErr: err, Err: "transaction start failed"}
 	}

-	query := "TRUNCATE `" + m.config.MigrationsTable + "`"
+	query := "DELETE FROM `" + m.config.MigrationsTable + "` LIMIT 1"
 	if _, err := tx.ExecContext(context.Background(), query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -328,7 +374,7 @@ func (m *Mysql) SetVersion(version int, dirty bool) error {
 		query := "INSERT INTO `" + m.config.MigrationsTable + "` (version, dirty) VALUES (?, ?)"
 		if _, err := tx.ExecContext(context.Background(), query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -370,7 +416,7 @@ func (m *Mysql) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -385,6 +431,9 @@ func (m *Mysql) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	if len(tableNames) > 0 {
 		// disable checking foreign key constraints until finished
@@ -420,17 +469,13 @@ func (m *Mysql) ensureVersionTable() (err error) {

 	defer func() {
 		if e := m.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

 	// check if migration table exists
 	var result string
-	query := `SHOW TABLES LIKE "` + m.config.MigrationsTable + `"`
+	query := `SHOW TABLES LIKE '` + m.config.MigrationsTable + `'`
 	if err := m.conn.QueryRowContext(context.Background(), query).Scan(&result); err != nil {
 		if err != sql.ErrNoRows {
 			return &database.Error{OrigErr: err, Query: []byte(query)}
@@ -2,26 +2,28 @@ package mysql

 import (
 	"context"
+	"crypto/ed25519"
+	"crypto/x509"
 	"database/sql"
 	sqldriver "database/sql/driver"
+	"encoding/pem"
 	"errors"
 	"fmt"
 	"log"
+	"math/big"
+	"math/rand"
+	"net/url"
+	"os"
 	"strconv"
 	"testing"
-)

-import (
 	"github.com/dhui/dktest"
 	"github.com/go-sql-driver/mysql"
-	"github.com/stretchr/testify/assert"
-)
-
-import (
 	"github.com/golang-migrate/migrate/v4"
 	dt "github.com/golang-migrate/migrate/v4/database/testing"
 	"github.com/golang-migrate/migrate/v4/dktesting"
 	_ "github.com/golang-migrate/migrate/v4/source/file"
+	"github.com/stretchr/testify/assert"
 )

 const defaultPort = 3306
@@ -31,12 +33,21 @@ var (
 		Env:          map[string]string{"MYSQL_ROOT_PASSWORD": "root", "MYSQL_DATABASE": "public"},
 		PortRequired: true, ReadyFunc: isReady,
 	}
+	optsAnsiQuotes = dktest.Options{
+		Env:          map[string]string{"MYSQL_ROOT_PASSWORD": "root", "MYSQL_DATABASE": "public"},
+		PortRequired: true, ReadyFunc: isReady,
+		Cmd: []string{"--sql-mode=ANSI_QUOTES"},
+	}
 	// Supported versions: https://www.mysql.com/support/supportedplatforms/database.html
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "mysql:5.5", Options: opts},
-		{ImageName: "mysql:5.6", Options: opts},
-		{ImageName: "mysql:5.7", Options: opts},
-		{ImageName: "mysql:8", Options: opts},
+		{ImageName: "mysql:8.0", Options: opts},
+		{ImageName: "mysql:8.4", Options: opts},
+		{ImageName: "mysql:9.0", Options: opts},
+	}
+	specsAnsiQuotes = []dktesting.ContainerSpec{
+		{ImageName: "mysql:8.0", Options: optsAnsiQuotes},
+		{ImageName: "mysql:8.4", Options: optsAnsiQuotes},
+		{ImageName: "mysql:9.0", Options: optsAnsiQuotes},
 	}
 )

@@ -69,7 +80,7 @@ func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
 }

 func Test(t *testing.T) {
-	// mysql.SetLogger(mysql.Logger(log.New(ioutil.Discard, "", log.Ltime)))
+	// mysql.SetLogger(mysql.Logger(log.New(io.Discard, "", log.Ltime)))

 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.Port(defaultPort)
@@ -102,7 +113,7 @@ func Test(t *testing.T) {
 }

 func TestMigrate(t *testing.T) {
-	// mysql.SetLogger(mysql.Logger(log.New(ioutil.Discard, "", log.Ltime)))
+	// mysql.SetLogger(mysql.Logger(log.New(io.Discard, "", log.Ltime)))

 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.Port(defaultPort)
@@ -139,6 +150,44 @@ func TestMigrate(t *testing.T) {
 	})
 }

+func TestMigrateAnsiQuotes(t *testing.T) {
+	// mysql.SetLogger(mysql.Logger(log.New(io.Discard, "", log.Ltime)))
+
+	dktesting.ParallelTest(t, specsAnsiQuotes, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := fmt.Sprintf("mysql://root:root@tcp(%v:%v)/public", ip, port)
+		p := &Mysql{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "public", d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+
+		// check ensureVersionTable
+		if err := d.(*Mysql).ensureVersionTable(); err != nil {
+			t.Fatal(err)
+		}
+		// check again
+		if err := d.(*Mysql).ensureVersionTable(); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
+
 func TestLockWorks(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.Port(defaultPort)
@@ -284,7 +333,42 @@ func TestExtractCustomQueryParams(t *testing.T) {
 	}
 }

+func createTmpCert(t *testing.T) string {
+	tmpCertFile, err := os.CreateTemp("", "migrate_test_cert")
+	if err != nil {
+		t.Fatal("Failed to create temp cert file:", err)
+	}
+	t.Cleanup(func() {
+		if err := os.Remove(tmpCertFile.Name()); err != nil {
+			t.Log("Failed to cleanup temp cert file:", err)
+		}
+	})
+
+	r := rand.New(rand.NewSource(0))
+	pub, priv, err := ed25519.GenerateKey(r)
+	if err != nil {
+		t.Fatal("Failed to generate ed25519 key for temp cert file:", err)
+	}
+	tmpl := x509.Certificate{
+		SerialNumber: big.NewInt(0),
+	}
+	derBytes, err := x509.CreateCertificate(r, &tmpl, &tmpl, pub, priv)
+	if err != nil {
+		t.Fatal("Failed to generate temp cert file:", err)
+	}
+	if err := pem.Encode(tmpCertFile, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
+		t.Fatal("Failed to encode ")
+	}
+	if err := tmpCertFile.Close(); err != nil {
+		t.Fatal("Failed to close temp cert file:", err)
+	}
+	return tmpCertFile.Name()
+}
+
 func TestURLToMySQLConfig(t *testing.T) {
+	tmpCertFilename := createTmpCert(t)
+	tmpCertFilenameEscaped := url.PathEscape(tmpCertFilename)
+
 	testcases := []struct {
 		name        string
 		urlStr      string
@@ -305,7 +389,7 @@ func TestURLToMySQLConfig(t *testing.T) {
 		// 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"},
+		// 	expectedDSN: "username::password@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"},
@@ -315,6 +399,9 @@ func TestURLToMySQLConfig(t *testing.T) {
 		{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"},
+		{name: "custom tls",
+			urlStr:      "mysql://username:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true&tls=custom&x-tls-ca=" + tmpCertFilenameEscaped,
+			expectedDSN: "username:password@tcp(127.0.0.1:3306)/myDB?multiStatements=true&tls=custom&x-tls-ca=" + tmpCertFilenameEscaped},
 	}
 	for _, tc := range testcases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -2,16 +2,15 @@ package neo4j

 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	neturl "net/url"
 	"strconv"
 	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4/database"
 	"github.com/golang-migrate/migrate/v4/database/multistmt"
-	"github.com/hashicorp/go-multierror"
 	"github.com/neo4j/neo4j-go-driver/neo4j"
 )

@@ -142,7 +141,7 @@ func (n *Neo4j) Run(migration io.Reader) (err error) {
 	}
 	defer func() {
 		if cerr := session.Close(); cerr != nil {
-			err = multierror.Append(err, cerr)
+			err = errors.Join(err, cerr)
 		}
 	}()

@@ -173,7 +172,7 @@ func (n *Neo4j) Run(migration io.Reader) (err error) {
 		return err
 	}

-	body, err := ioutil.ReadAll(migration)
+	body, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -189,7 +188,7 @@ func (n *Neo4j) SetVersion(version int, dirty bool) (err error) {
 	}
 	defer func() {
 		if cerr := session.Close(); cerr != nil {
-			err = multierror.Append(err, cerr)
+			err = errors.Join(err, cerr)
 		}
 	}()

@@ -214,7 +213,7 @@ func (n *Neo4j) Version() (version int, dirty bool, err error) {
 	}
 	defer func() {
 		if cerr := session.Close(); cerr != nil {
-			err = multierror.Append(err, cerr)
+			err = errors.Join(err, cerr)
 		}
 	}()

@@ -262,7 +261,7 @@ func (n *Neo4j) Drop() (err error) {
 	}
 	defer func() {
 		if cerr := session.Close(); cerr != nil {
-			err = multierror.Append(err, cerr)
+			err = errors.Join(err, cerr)
 		}
 	}()

@@ -279,7 +278,7 @@ func (n *Neo4j) ensureVersionConstraint() (err error) {
 	}
 	defer func() {
 		if cerr := session.Close(); cerr != nil {
-			err = multierror.Append(err, cerr)
+			err = errors.Join(err, cerr)
 		}
 	}()

@@ -8,13 +8,15 @@ import (
 )

 const reservedChars = "!#$%&'()*+,/:;=?@[]"
+const reservedCharTestNamePrefix = "reserved char "

 const baseUsername = "username"

+const scheme = "database://"
+
 // TestUserUnencodedReservedURLChars documents the behavior of using unencoded reserved characters in usernames with
 // net/url Parse()
 func TestUserUnencodedReservedURLChars(t *testing.T) {
-	scheme := "database://"
 	urlSuffix := "password@localhost:12345/myDB?someParam=true"
 	urlSuffixAndSep := ":" + urlSuffix

@@ -64,7 +66,7 @@ func TestUserUnencodedReservedURLChars(t *testing.T) {
 	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) {
+		t.Run(reservedCharTestNamePrefix+tc.char, func(t *testing.T) {
 			s := scheme + baseUsername + tc.char + urlSuffixAndSep
 			u, err := url.Parse(s)
 			if err == nil {
@@ -98,13 +100,12 @@ func TestUserUnencodedReservedURLChars(t *testing.T) {
 }

 func TestUserEncodedReservedURLChars(t *testing.T) {
-	scheme := "database://"
 	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) {
+		t.Run(reservedCharTestNamePrefix+c, func(t *testing.T) {
 			encodedChar := "%" + hex.EncodeToString([]byte(c))
 			s := scheme + baseUsername + encodedChar + urlSuffixAndSep
 			expectedUsername := baseUsername + c
@@ -126,7 +127,7 @@ func TestUserEncodedReservedURLChars(t *testing.T) {
 // with net/url Parse()
 func TestPasswordUnencodedReservedURLChars(t *testing.T) {
 	username := baseUsername
-	schemeAndUsernameAndSep := "database://" + username + ":"
+	schemeAndUsernameAndSep := scheme + username + ":"
 	basePassword := "password"
 	urlSuffixAndSep := "@localhost:12345/myDB?someParam=true"

@@ -174,7 +175,7 @@ func TestPasswordUnencodedReservedURLChars(t *testing.T) {
 	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) {
+		t.Run(reservedCharTestNamePrefix+tc.char, func(t *testing.T) {
 			s := schemeAndUsernameAndSep + basePassword + tc.char + urlSuffixAndSep
 			u, err := url.Parse(s)
 			if err == nil {
@@ -213,13 +214,13 @@ func TestPasswordUnencodedReservedURLChars(t *testing.T) {

 func TestPasswordEncodedReservedURLChars(t *testing.T) {
 	username := baseUsername
-	schemeAndUsernameAndSep := "database://" + username + ":"
+	schemeAndUsernameAndSep := scheme + 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) {
+		t.Run(reservedCharTestNamePrefix+c, func(t *testing.T) {
 			encodedChar := "%" + hex.EncodeToString([]byte(c))
 			s := schemeAndUsernameAndSep + basePassword + encodedChar + urlSuffixAndSep
 			expectedPassword := basePassword + c
@@ -0,0 +1,43 @@
+# pgx
+
+This package is for [pgx/v4](https://pkg.go.dev/github.com/jackc/pgx/v4). A backend for the newer [pgx/v5](https://pkg.go.dev/github.com/jackc/pgx/v5) is [also available](v5).
+
+`pgx://user:password@host:port/dbname?query`
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `x-migrations-table-quoted` | `MigrationsTableQuoted` | By default, migrate quotes the migration table for SQL injection safety reasons. This option disable quoting and naively checks that you have quoted the migration table name. e.g. `"my_schema"."schema_migrations"` |
+| `x-statement-timeout` | `StatementTimeout` | Abort any statement that takes more than the specified number of milliseconds |
+| `x-multi-statement` | `MultiStatementEnabled` | Enable multi-statement execution (default: false) |
+| `x-multi-statement-max-size` | `MultiStatementMaxSize` | Maximum size of single statement in bytes (default: 10MB) |
+| `x-lock-strategy` | `LockStrategy` | Strategy used for locking during migration (default: advisory) |
+| `x-lock-table` | `LockTable` | Name of the table which maintains the migration lock (default: schema_lock) |
+| `dbname` | `DatabaseName` | The name of the database to connect to |
+| `search_path` | | This variable specifies the order in which schemas are searched when an object is referenced by a simple name with no schema specified. |
+| `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) |
+| `fallback_application_name` | | An application_name to fall back to if one isn't provided. |
+| `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) |
+
+
+## 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://www.postgresql.org/docs/current/static/transaction-iso.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>`.
+
+## Multi-statement mode
+
+In PostgreSQL running multiple SQL statements in one `Exec` executes them inside a transaction. Sometimes this
+behavior is not desirable because some statements can be only run outside of transaction (e.g.
+`CREATE INDEX CONCURRENTLY`). If you want to use `CREATE INDEX CONCURRENTLY` without activating multi-statement mode
+you have to put such statements in a separate migration files.
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;
@@ -0,0 +1,5 @@
+CREATE TABLE users (
+  user_id integer unique,
+  name    varchar(40),
+  email   varchar(40)
+);
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS city;
@@ -0,0 +1,3 @@
+ALTER TABLE users ADD COLUMN city varchar(100);
+
+
@@ -0,0 +1 @@
+DROP INDEX IF EXISTS users_email_index;
@@ -0,0 +1,3 @@
+CREATE UNIQUE INDEX CONCURRENTLY 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.
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS books;
@@ -0,0 +1,5 @@
+CREATE TABLE books (
+  user_id integer,
+  name    varchar(40),
+  author  varchar(40)
+);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS movies;
@@ -0,0 +1,5 @@
+CREATE TABLE movies (
+  user_id   integer,
+  name      varchar(40),
+  director  varchar(40)
+);
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -0,0 +1,617 @@
+//go:build go1.9
+
+package pgx
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	nurl "net/url"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/golang-migrate/migrate/v4/database/multistmt"
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgerrcode"
+	_ "github.com/jackc/pgx/v4/stdlib"
+	"github.com/lib/pq"
+)
+
+const (
+	LockStrategyAdvisory = "advisory"
+	LockStrategyTable    = "table"
+)
+
+func init() {
+	db := Postgres{}
+	database.Register("pgx", &db)
+	database.Register("pgx4", &db)
+}
+
+var (
+	multiStmtDelimiter = []byte(";")
+
+	DefaultMigrationsTable       = "schema_migrations"
+	DefaultMultiStatementMaxSize = 10 * 1 << 20 // 10 MB
+	DefaultLockTable             = "schema_lock"
+	DefaultLockStrategy          = LockStrategyAdvisory
+)
+
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+	ErrNoSchema       = fmt.Errorf("no schema")
+	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
+)
+
+type Config struct {
+	MigrationsTable       string
+	DatabaseName          string
+	SchemaName            string
+	LockTable             string
+	LockStrategy          string
+	migrationsSchemaName  string
+	migrationsTableName   string
+	StatementTimeout      time.Duration
+	MigrationsTableQuoted bool
+	MultiStatementEnabled bool
+	MultiStatementMaxSize int
+}
+
+type Postgres struct {
+	// Locking and unlocking need to use the same connection
+	conn     *sql.Conn
+	db       *sql.DB
+	isLocked atomic.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
+	}
+
+	if config.DatabaseName == "" {
+		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 config.SchemaName == "" {
+		query := `SELECT CURRENT_SCHEMA()`
+		var schemaName string
+		if err := instance.QueryRow(query).Scan(&schemaName); err != nil {
+			return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+
+		if len(schemaName) == 0 {
+			return nil, ErrNoSchema
+		}
+
+		config.SchemaName = schemaName
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	if len(config.LockTable) == 0 {
+		config.LockTable = DefaultLockTable
+	}
+
+	if len(config.LockStrategy) == 0 {
+		config.LockStrategy = DefaultLockStrategy
+	}
+
+	config.migrationsSchemaName = config.SchemaName
+	config.migrationsTableName = config.MigrationsTable
+	if config.MigrationsTableQuoted {
+		re := regexp.MustCompile(`"(.*?)"`)
+		result := re.FindAllStringSubmatch(config.MigrationsTable, -1)
+		config.migrationsTableName = result[len(result)-1][1]
+		if len(result) == 2 {
+			config.migrationsSchemaName = result[0][1]
+		} else if len(result) > 2 {
+			return nil, fmt.Errorf("\"%s\" MigrationsTable contains too many dot characters", config.MigrationsTable)
+		}
+	}
+
+	conn, err := instance.Conn(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
+	px := &Postgres{
+		conn:   conn,
+		db:     instance,
+		config: config,
+	}
+
+	if err := px.ensureLockTable(); err != nil {
+		return nil, err
+	}
+
+	if err := px.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// Driver is registered as pgx, but connection string must use postgres schema
+	// when making actual connection
+	// i.e. pgx://user:password@host:port/db => postgres://user:password@host:port/db
+	purl.Scheme = "postgres"
+
+	db, err := sql.Open("pgx/v4", migrate.FilterCustomQuery(purl).String())
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	migrationsTableQuoted := false
+	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
+		migrationsTableQuoted, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
+		}
+	}
+	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
+		return nil, fmt.Errorf("x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: %s", migrationsTable)
+	}
+
+	statementTimeoutString := purl.Query().Get("x-statement-timeout")
+	statementTimeout := 0
+	if statementTimeoutString != "" {
+		statementTimeout, err = strconv.Atoi(statementTimeoutString)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	multiStatementMaxSize := DefaultMultiStatementMaxSize
+	if s := purl.Query().Get("x-multi-statement-max-size"); len(s) > 0 {
+		multiStatementMaxSize, err = strconv.Atoi(s)
+		if err != nil {
+			return nil, err
+		}
+		if multiStatementMaxSize <= 0 {
+			multiStatementMaxSize = DefaultMultiStatementMaxSize
+		}
+	}
+
+	multiStatementEnabled := false
+	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
+		multiStatementEnabled, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
+		}
+	}
+
+	lockStrategy := purl.Query().Get("x-lock-strategy")
+	lockTable := purl.Query().Get("x-lock-table")
+
+	px, err := WithInstance(db, &Config{
+		DatabaseName:          purl.Path,
+		MigrationsTable:       migrationsTable,
+		MigrationsTableQuoted: migrationsTableQuoted,
+		StatementTimeout:      time.Duration(statementTimeout) * time.Millisecond,
+		MultiStatementEnabled: multiStatementEnabled,
+		MultiStatementMaxSize: multiStatementMaxSize,
+		LockStrategy:          lockStrategy,
+		LockTable:             lockTable,
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Close() error {
+	connErr := p.conn.Close()
+	dbErr := p.db.Close()
+	if connErr != nil || dbErr != nil {
+		return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)
+	}
+	return nil
+}
+
+func (p *Postgres) Lock() error {
+	return database.CasRestoreOnErr(&p.isLocked, false, true, database.ErrLocked, func() error {
+		switch p.config.LockStrategy {
+		case LockStrategyAdvisory:
+			return p.applyAdvisoryLock()
+		case LockStrategyTable:
+			return p.applyTableLock()
+		default:
+			return fmt.Errorf("unknown lock strategy \"%s\"", p.config.LockStrategy)
+		}
+	})
+}
+
+func (p *Postgres) Unlock() error {
+	return database.CasRestoreOnErr(&p.isLocked, true, false, database.ErrNotLocked, func() error {
+		switch p.config.LockStrategy {
+		case LockStrategyAdvisory:
+			return p.releaseAdvisoryLock()
+		case LockStrategyTable:
+			return p.releaseTableLock()
+		default:
+			return fmt.Errorf("unknown lock strategy \"%s\"", p.config.LockStrategy)
+		}
+	})
+}
+
+// https://www.postgresql.org/docs/9.6/static/explicit-locking.html#ADVISORY-LOCKS
+func (p *Postgres) applyAdvisoryLock() error {
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+	if err != nil {
+		return err
+	}
+
+	// This will wait indefinitely until the lock can be acquired.
+	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)}
+	}
+	return nil
+}
+
+func (p *Postgres) applyTableLock() error {
+	tx, err := p.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+	defer func() {
+		errRollback := tx.Rollback()
+		if errRollback != nil {
+			err = errors.Join(err, errRollback)
+		}
+	}()
+
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	query := "SELECT * FROM " + pq.QuoteIdentifier(p.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 func() {
+		if errClose := rows.Close(); errClose != nil {
+			err = errors.Join(err, errClose)
+		}
+	}()
+
+	// If row exists at all, lock is present
+	locked := rows.Next()
+	if locked {
+		return database.ErrLocked
+	}
+
+	query = "INSERT INTO " + pq.QuoteIdentifier(p.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 tx.Commit()
+}
+
+func (p *Postgres) releaseAdvisoryLock() error {
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+	if err != nil {
+		return err
+	}
+
+	query := `SELECT pg_advisory_unlock($1)`
+	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+func (p *Postgres) releaseTableLock() error {
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	query := "DELETE FROM " + pq.QuoteIdentifier(p.config.LockTable) + " WHERE lock_id = $1"
+	if _, err := p.db.Exec(query, aid); err != nil {
+		return database.Error{OrigErr: err, Err: "failed to release migration lock", Query: []byte(query)}
+	}
+
+	return nil
+}
+
+func (p *Postgres) Run(migration io.Reader) error {
+	if p.config.MultiStatementEnabled {
+		var err error
+		if e := multistmt.Parse(migration, multiStmtDelimiter, p.config.MultiStatementMaxSize, func(m []byte) bool {
+			if err = p.runStatement(m); err != nil {
+				return false
+			}
+			return true
+		}); e != nil {
+			return e
+		}
+		return err
+	}
+	migr, err := io.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	return p.runStatement(migr)
+}
+
+func (p *Postgres) runStatement(statement []byte) error {
+	ctx := context.Background()
+	if p.config.StatementTimeout != 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, p.config.StatementTimeout)
+		defer cancel()
+	}
+	query := string(statement)
+	if strings.TrimSpace(query) == "" {
+		return nil
+	}
+	if _, err := p.conn.ExecContext(ctx, query); err != nil {
+
+		if pgErr, ok := err.(*pgconn.PgError); ok {
+			var line uint
+			var col uint
+			var lineColOK bool
+			line, col, lineColOK = computeLineFromPos(query, int(pgErr.Position))
+			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: statement, Line: line}
+		}
+		return database.Error{OrigErr: err, Err: "migration failed", Query: statement}
+	}
+	return nil
+}
+
+func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
+	// replace crlf with lf
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	// 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.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+
+	query := `TRUNCATE ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName)
+	if _, err := tx.Exec(query); err != nil {
+		if errRollback := tx.Rollback(); errRollback != nil {
+			err = errors.Join(err, errRollback)
+		}
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	// Also re-write the schema version for nil dirty versions to prevent
+	// empty schema version for failed down migration on the first migration
+	// See: https://github.com/golang-migrate/migrate/issues/330
+	if version >= 0 || (version == database.NilVersion && dirty) {
+		query = `INSERT INTO ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` (version, dirty) VALUES ($1, $2)`
+		if _, err := tx.Exec(query, version, dirty); err != nil {
+			if errRollback := tx.Rollback(); errRollback != nil {
+				err = errors.Join(err, errRollback)
+			}
+			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 (p *Postgres) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` LIMIT 1`
+	err = p.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*pgconn.PgError); ok {
+			if e.SQLState() == pgerrcode.UndefinedTable {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (p *Postgres) Drop() (err error) {
+	// select all tables in current schema
+	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema()) AND table_type='BASE TABLE'`
+	tables, err := p.conn.QueryContext(context.Background(), query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer func() {
+		if errClose := tables.Close(); errClose != nil {
+			err = errors.Join(err, errClose)
+		}
+	}()
+
+	// delete one table after another
+	tableNames := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+
+		// do not drop lock table
+		if tableName == p.config.LockTable && p.config.LockStrategy == LockStrategyTable {
+			continue
+		}
+
+		if len(tableName) > 0 {
+			tableNames = append(tableNames, tableName)
+		}
+	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(tableNames) > 0 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = `DROP TABLE IF EXISTS ` + quoteIdentifier(t) + ` CASCADE`
+			if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+	}
+
+	return nil
+}
+
+// ensureVersionTable checks if versions table exists and, if not, creates it.
+// Note that this function locks the database, which deviates from the usual
+// convention of "caller locks" in the Postgres type.
+func (p *Postgres) ensureVersionTable() (err error) {
+	if err = p.Lock(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if e := p.Unlock(); e != nil {
+			err = errors.Join(err, e)
+		}
+	}()
+
+	// This block checks whether the `MigrationsTable` already exists. This is useful because it allows read only postgres
+	// users to also check the current version of the schema. Previously, even if `MigrationsTable` existed, the
+	// `CREATE TABLE IF NOT EXISTS...` query would fail because the user does not have the CREATE permission.
+	// Taken from https://github.com/mattes/migrate/blob/master/database/postgres/postgres.go#L258
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2 LIMIT 1`
+	row := p.conn.QueryRowContext(context.Background(), query, p.config.migrationsSchemaName, p.config.migrationsTableName)
+
+	var count int
+	err = row.Scan(&count)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if count == 1 {
+		return nil
+	}
+
+	query = `CREATE TABLE IF NOT EXISTS ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` (version bigint not null primary key, dirty boolean not null)`
+	if _, err = p.conn.ExecContext(context.Background(), query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+func (p *Postgres) ensureLockTable() error {
+	if p.config.LockStrategy != LockStrategyTable {
+		return nil
+	}
+
+	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.LockTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	query = `CREATE TABLE ` + pq.QuoteIdentifier(p.config.LockTable) + ` (lock_id BIGINT NOT NULL PRIMARY KEY)`
+	if _, err := p.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+// Copied from lib/pq implementation: https://github.com/lib/pq/blob/v1.9.0/conn.go#L1611
+func quoteIdentifier(name string) string {
+	end := strings.IndexRune(name, 0)
+	if end > -1 {
+		name = name[:end]
+	}
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
+}
@@ -0,0 +1,786 @@
+package pgx
+
+// error codes https://github.com/jackc/pgerrcode/blob/master/errcode.go
+
+import (
+	"context"
+	"database/sql"
+	sqldriver "database/sql/driver"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/dhui/dktest"
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+
+	dt "github.com/golang-migrate/migrate/v4/database/testing"
+	"github.com/golang-migrate/migrate/v4/dktesting"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+)
+
+const (
+	pgPassword = "postgres"
+)
+
+var (
+	opts = dktest.Options{
+		Env:          map[string]string{"POSTGRES_PASSWORD": pgPassword},
+		PortRequired: true, ReadyFunc: isReady}
+	// Supported versions: https://www.postgresql.org/support/versioning/
+	specs = []dktesting.ContainerSpec{
+		{ImageName: "postgres:13", Options: opts},
+		{ImageName: "postgres:14", Options: opts},
+		{ImageName: "postgres:15", Options: opts},
+		{ImageName: "postgres:16", Options: opts},
+		{ImageName: "postgres:17", Options: opts},
+	}
+)
+
+func pgConnectionString(host, port string, options ...string) string {
+	options = append(options, "sslmode=disable")
+	return fmt.Sprintf("postgres://postgres:%s@%s:%s/postgres?%s", pgPassword, host, port, strings.Join(options, "&"))
+}
+
+func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
+	ip, port, err := c.FirstPort()
+	if err != nil {
+		return false
+	}
+
+	db, err := sql.Open("pgx", pgConnectionString(ip, port))
+	if err != nil {
+		return false
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			log.Println("close error:", err)
+		}
+	}()
+	if err = db.PingContext(ctx); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn, io.EOF:
+			return false
+		default:
+			log.Println(err)
+		}
+		return false
+	}
+
+	return true
+}
+
+func mustRun(t *testing.T, d database.Driver, statements []string) {
+	for _, statement := range statements {
+		if err := d.Run(strings.NewReader(statement)); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func Test(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		dt.Test(t, d, []byte("SELECT 1"))
+	})
+}
+
+func TestMigrate(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "pgx", d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+	})
+}
+
+func TestMigrateLockTable(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-lock-strategy=table", "x-lock-table=lock_table")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "pgx", d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+	})
+}
+
+func TestMultipleStatements(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if err := d.Run(strings.NewReader("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).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 {
+			t.Fatalf("expected table bar to exist")
+		}
+	})
+}
+
+func TestMultipleStatementsInMultiStatementMode(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-multi-statement=true")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if err := d.Run(strings.NewReader("CREATE TABLE foo (foo text); CREATE INDEX CONCURRENTLY idx_foo ON foo (foo);")); err != nil {
+			t.Fatalf("expected err to be nil, got %v", err)
+		}
+
+		// make sure created index exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM pg_indexes WHERE schemaname = (SELECT current_schema()) AND indexname = 'idx_foo')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table bar to exist")
+		}
+	})
+}
+
+func TestErrorParsing(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		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: ERROR: syntax error at or near "TABLEE" (SQLSTATE 42601))`
+		if err := d.Run(strings.NewReader("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) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-custom=foobar")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+	})
+}
+
+func TestWithSchema(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		// create foobar schema
+		if err := d.Run(strings.NewReader("CREATE SCHEMA foobar AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+		if err := d.SetVersion(1, false); err != nil {
+			t.Fatal(err)
+		}
+
+		// re-connect using that schema
+		d2, err := p.Open(pgConnectionString(ip, port, "search_path=foobar"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d2.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		version, _, err := d2.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != database.NilVersion {
+			t.Fatal("expected NilVersion")
+		}
+
+		// now update version and compare
+		if err := d2.SetVersion(2, false); err != nil {
+			t.Fatal(err)
+		}
+		version, _, err = d2.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != 2 {
+			t.Fatal("expected version 2")
+		}
+
+		// meanwhile, the public schema still has the other version
+		version, _, err = d.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != 1 {
+			t.Fatal("expected version 2")
+		}
+	})
+}
+
+func TestMigrationTableOption(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, _ := p.Open(addr)
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		// create migrate schema
+		if err := d.Run(strings.NewReader("CREATE SCHEMA migrate AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+
+		// bad unquoted x-migrations-table parameter
+		wantErr := "x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: migrate.schema_migrations"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// too many quoted x-migrations-table parameters
+		wantErr = "\"\"migrate\".\"schema_migrations\".\"toomany\"\" MigrationsTable contains too many dot characters"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\".\"toomany\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// good quoted x-migrations-table parameter
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// make sure migrate.schema_migrations table exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'schema_migrations' AND table_schema = 'migrate')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table migrate.schema_migrations to exist")
+		}
+
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'migrate.schema_migrations' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table 'migrate.schema_migrations' to exist")
+		}
+
+	})
+}
+
+func TestFailToCreateTableWithoutPermissions(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		defer func() {
+			if d2 == nil {
+				return
+			}
+			if err := d2.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		var e *database.Error
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+
+		// re-connect using that x-migrations-table and x-migrations-table-quoted
+		d2, err = p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"barfoo\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+	})
+}
+
+func TestCheckBeforeCreateTable(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"GRANT CREATE ON SCHEMA barfoo TO not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := d2.Close(); err != nil {
+			t.Fatal(err)
+		}
+
+		// revoke privileges
+		mustRun(t, d, []string{
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d3, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		version, _, err := d3.Version()
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if version != database.NilVersion {
+			t.Fatal("Unexpected version, want database.NilVersion. Got: ", version)
+		}
+
+		defer func() {
+			if err := d3.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+	})
+}
+
+func TestParallelSchema(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create foo and bar schemas
+		if err := d.Run(strings.NewReader("CREATE SCHEMA foo AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+		if err := d.Run(strings.NewReader("CREATE SCHEMA bar AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+
+		// re-connect using that schemas
+		dfoo, err := p.Open(pgConnectionString(ip, port, "search_path=foo"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := dfoo.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		dbar, err := p.Open(pgConnectionString(ip, port, "search_path=bar"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := dbar.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		if err := dfoo.Lock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dbar.Lock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dbar.Unlock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dfoo.Unlock(); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
+
+func TestPostgres_Lock(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(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 TestWithInstance_Concurrent(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// The number of concurrent processes running WithInstance
+		const concurrency = 30
+
+		// We can instantiate a single database handle because it is
+		// actually a connection pool, and so, each of the below go
+		// routines will have a high probability of using a separate
+		// connection, which is something we want to exercise.
+		db, err := sql.Open("pgx", pgConnectionString(ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		db.SetMaxIdleConns(concurrency)
+		db.SetMaxOpenConns(concurrency)
+
+		var wg sync.WaitGroup
+		defer wg.Wait()
+
+		wg.Add(concurrency)
+		for i := 0; i < concurrency; i++ {
+			go func(i int) {
+				defer wg.Done()
+				_, err := WithInstance(db, &Config{})
+				if err != nil {
+					t.Errorf("process %d error: %s", i, err)
+				}
+			}(i)
+		}
+	})
+}
+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.ReplaceAll(input, "\n", "\r\n")
+					}
+					if nonASCII {
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
+					}
+					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)
+		})
+	}
+}
@@ -0,0 +1,41 @@
+# pgx
+
+This package is for [pgx/v5](https://pkg.go.dev/github.com/jackc/pgx/v5). A backend for the older [pgx/v4](https://pkg.go.dev/github.com/jackc/pgx/v4). is [also available](..).
+
+`pgx5://user:password@host:port/dbname?query`
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `x-migrations-table-quoted` | `MigrationsTableQuoted` | By default, migrate quotes the migration table for SQL injection safety reasons. This option disable quoting and naively checks that you have quoted the migration table name. e.g. `"my_schema"."schema_migrations"` |
+| `x-statement-timeout` | `StatementTimeout` | Abort any statement that takes more than the specified number of milliseconds |
+| `x-multi-statement` | `MultiStatementEnabled` | Enable multi-statement execution (default: false) |
+| `x-multi-statement-max-size` | `MultiStatementMaxSize` | Maximum size of single statement in bytes (default: 10MB) |
+| `dbname` | `DatabaseName` | The name of the database to connect to |
+| `search_path` | | This variable specifies the order in which schemas are searched when an object is referenced by a simple name with no schema specified. |
+| `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) |
+| `fallback_application_name` | | An application_name to fall back to if one isn't provided. |
+| `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) |
+
+
+## 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://www.postgresql.org/docs/current/static/transaction-iso.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>`.
+
+## Multi-statement mode
+
+In PostgreSQL running multiple SQL statements in one `Exec` executes them inside a transaction. Sometimes this
+behavior is not desirable because some statements can be only run outside of transaction (e.g.
+`CREATE INDEX CONCURRENTLY`). If you want to use `CREATE INDEX CONCURRENTLY` without activating multi-statement mode
+you have to put such statements in a separate migration files.
@@ -0,0 +1,480 @@
+//go:build go1.9
+
+package pgx
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	nurl "net/url"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/golang-migrate/migrate/v4/database/multistmt"
+	"github.com/jackc/pgerrcode"
+	"github.com/jackc/pgx/v5/pgconn"
+	_ "github.com/jackc/pgx/v5/stdlib"
+)
+
+func init() {
+	db := Postgres{}
+	database.Register("pgx5", &db)
+}
+
+var (
+	multiStmtDelimiter = []byte(";")
+
+	DefaultMigrationsTable       = "schema_migrations"
+	DefaultMultiStatementMaxSize = 10 * 1 << 20 // 10 MB
+)
+
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+	ErrNoSchema       = fmt.Errorf("no schema")
+)
+
+type Config struct {
+	MigrationsTable       string
+	DatabaseName          string
+	SchemaName            string
+	migrationsSchemaName  string
+	migrationsTableName   string
+	StatementTimeout      time.Duration
+	MigrationsTableQuoted bool
+	MultiStatementEnabled bool
+	MultiStatementMaxSize int
+}
+
+type Postgres struct {
+	// Locking and unlocking need to use the same connection
+	conn     *sql.Conn
+	db       *sql.DB
+	isLocked atomic.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
+	}
+
+	if config.DatabaseName == "" {
+		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 config.SchemaName == "" {
+		query := `SELECT CURRENT_SCHEMA()`
+		var schemaName string
+		if err := instance.QueryRow(query).Scan(&schemaName); err != nil {
+			return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+
+		if len(schemaName) == 0 {
+			return nil, ErrNoSchema
+		}
+
+		config.SchemaName = schemaName
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	config.migrationsSchemaName = config.SchemaName
+	config.migrationsTableName = config.MigrationsTable
+	if config.MigrationsTableQuoted {
+		re := regexp.MustCompile(`"(.*?)"`)
+		result := re.FindAllStringSubmatch(config.MigrationsTable, -1)
+		config.migrationsTableName = result[len(result)-1][1]
+		if len(result) == 2 {
+			config.migrationsSchemaName = result[0][1]
+		} else if len(result) > 2 {
+			return nil, fmt.Errorf("\"%s\" MigrationsTable contains too many dot characters", config.MigrationsTable)
+		}
+	}
+
+	conn, err := instance.Conn(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
+	px := &Postgres{
+		conn:   conn,
+		db:     instance,
+		config: config,
+	}
+
+	if err := px.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// Driver is registered as pgx, but connection string must use postgres schema
+	// when making actual connection
+	// i.e. pgx://user:password@host:port/db => postgres://user:password@host:port/db
+	purl.Scheme = "postgres"
+
+	db, err := sql.Open("pgx/v5", migrate.FilterCustomQuery(purl).String())
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	migrationsTableQuoted := false
+	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
+		migrationsTableQuoted, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
+		}
+	}
+	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
+		return nil, fmt.Errorf("x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: %s", migrationsTable)
+	}
+
+	statementTimeoutString := purl.Query().Get("x-statement-timeout")
+	statementTimeout := 0
+	if statementTimeoutString != "" {
+		statementTimeout, err = strconv.Atoi(statementTimeoutString)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	multiStatementMaxSize := DefaultMultiStatementMaxSize
+	if s := purl.Query().Get("x-multi-statement-max-size"); len(s) > 0 {
+		multiStatementMaxSize, err = strconv.Atoi(s)
+		if err != nil {
+			return nil, err
+		}
+		if multiStatementMaxSize <= 0 {
+			multiStatementMaxSize = DefaultMultiStatementMaxSize
+		}
+	}
+
+	multiStatementEnabled := false
+	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
+		multiStatementEnabled, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
+		}
+	}
+
+	px, err := WithInstance(db, &Config{
+		DatabaseName:          purl.Path,
+		MigrationsTable:       migrationsTable,
+		MigrationsTableQuoted: migrationsTableQuoted,
+		StatementTimeout:      time.Duration(statementTimeout) * time.Millisecond,
+		MultiStatementEnabled: multiStatementEnabled,
+		MultiStatementMaxSize: multiStatementMaxSize,
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Close() error {
+	connErr := p.conn.Close()
+	dbErr := p.db.Close()
+	if connErr != nil || dbErr != nil {
+		return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)
+	}
+	return nil
+}
+
+// https://www.postgresql.org/docs/9.6/static/explicit-locking.html#ADVISORY-LOCKS
+func (p *Postgres) Lock() error {
+	return database.CasRestoreOnErr(&p.isLocked, false, true, database.ErrLocked, func() error {
+		aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+		if err != nil {
+			return err
+		}
+
+		// This will wait indefinitely until the lock can be acquired.
+		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)}
+		}
+		return nil
+	})
+}
+
+func (p *Postgres) Unlock() error {
+	return database.CasRestoreOnErr(&p.isLocked, true, false, database.ErrNotLocked, func() error {
+		aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+		if err != nil {
+			return err
+		}
+
+		query := `SELECT pg_advisory_unlock($1)`
+		if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+		return nil
+	})
+}
+
+func (p *Postgres) Run(migration io.Reader) error {
+	if p.config.MultiStatementEnabled {
+		var err error
+		if e := multistmt.Parse(migration, multiStmtDelimiter, p.config.MultiStatementMaxSize, func(m []byte) bool {
+			if err = p.runStatement(m); err != nil {
+				return false
+			}
+			return true
+		}); e != nil {
+			return e
+		}
+		return err
+	}
+	migr, err := io.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	return p.runStatement(migr)
+}
+
+func (p *Postgres) runStatement(statement []byte) error {
+	ctx := context.Background()
+	if p.config.StatementTimeout != 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, p.config.StatementTimeout)
+		defer cancel()
+	}
+	query := string(statement)
+	if strings.TrimSpace(query) == "" {
+		return nil
+	}
+	if _, err := p.conn.ExecContext(ctx, query); err != nil {
+
+		if pgErr, ok := err.(*pgconn.PgError); ok {
+			var line uint
+			var col uint
+			var lineColOK bool
+			line, col, lineColOK = computeLineFromPos(query, int(pgErr.Position))
+			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: statement, Line: line}
+		}
+		return database.Error{OrigErr: err, Err: "migration failed", Query: statement}
+	}
+	return nil
+}
+
+func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
+	// replace crlf with lf
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	// 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.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+
+	query := `TRUNCATE ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName)
+	if _, err := tx.Exec(query); err != nil {
+		if errRollback := tx.Rollback(); errRollback != nil {
+			err = errors.Join(err, errRollback)
+		}
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	// Also re-write the schema version for nil dirty versions to prevent
+	// empty schema version for failed down migration on the first migration
+	// See: https://github.com/golang-migrate/migrate/issues/330
+	if version >= 0 || (version == database.NilVersion && dirty) {
+		query = `INSERT INTO ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` (version, dirty) VALUES ($1, $2)`
+		if _, err := tx.Exec(query, version, dirty); err != nil {
+			if errRollback := tx.Rollback(); errRollback != nil {
+				err = errors.Join(err, errRollback)
+			}
+			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 (p *Postgres) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` LIMIT 1`
+	err = p.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*pgconn.PgError); ok {
+			if e.SQLState() == pgerrcode.UndefinedTable {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (p *Postgres) Drop() (err error) {
+	// select all tables in current schema
+	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema()) AND table_type='BASE TABLE'`
+	tables, err := p.conn.QueryContext(context.Background(), query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer func() {
+		if errClose := tables.Close(); errClose != nil {
+			err = errors.Join(err, errClose)
+		}
+	}()
+
+	// 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 err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(tableNames) > 0 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = `DROP TABLE IF EXISTS ` + quoteIdentifier(t) + ` CASCADE`
+			if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+	}
+
+	return nil
+}
+
+// ensureVersionTable checks if versions table exists and, if not, creates it.
+// Note that this function locks the database, which deviates from the usual
+// convention of "caller locks" in the Postgres type.
+func (p *Postgres) ensureVersionTable() (err error) {
+	if err = p.Lock(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if e := p.Unlock(); e != nil {
+			err = errors.Join(err, e)
+		}
+	}()
+
+	// This block checks whether the `MigrationsTable` already exists. This is useful because it allows read only postgres
+	// users to also check the current version of the schema. Previously, even if `MigrationsTable` existed, the
+	// `CREATE TABLE IF NOT EXISTS...` query would fail because the user does not have the CREATE permission.
+	// Taken from https://github.com/mattes/migrate/blob/master/database/postgres/postgres.go#L258
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2 LIMIT 1`
+	row := p.conn.QueryRowContext(context.Background(), query, p.config.migrationsSchemaName, p.config.migrationsTableName)
+
+	var count int
+	err = row.Scan(&count)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if count == 1 {
+		return nil
+	}
+
+	query = `CREATE TABLE IF NOT EXISTS ` + quoteIdentifier(p.config.migrationsSchemaName) + `.` + quoteIdentifier(p.config.migrationsTableName) + ` (version bigint not null primary key, dirty boolean not null)`
+	if _, err = p.conn.ExecContext(context.Background(), query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+// Copied from lib/pq implementation: https://github.com/lib/pq/blob/v1.9.0/conn.go#L1611
+func quoteIdentifier(name string) string {
+	end := strings.IndexRune(name, 0)
+	if end > -1 {
+		name = name[:end]
+	}
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
+}
@@ -0,0 +1,761 @@
+package pgx
+
+// error codes https://github.com/jackc/pgerrcode/blob/master/errcode.go
+
+import (
+	"context"
+	"database/sql"
+	sqldriver "database/sql/driver"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/golang-migrate/migrate/v4"
+
+	"github.com/dhui/dktest"
+
+	"github.com/golang-migrate/migrate/v4/database"
+	dt "github.com/golang-migrate/migrate/v4/database/testing"
+	"github.com/golang-migrate/migrate/v4/dktesting"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+)
+
+const (
+	pgPassword = "postgres"
+)
+
+var (
+	opts = dktest.Options{
+		Env:          map[string]string{"POSTGRES_PASSWORD": pgPassword},
+		PortRequired: true, ReadyFunc: isReady}
+	// Supported versions: https://www.postgresql.org/support/versioning/
+	specs = []dktesting.ContainerSpec{
+		{ImageName: "postgres:13", Options: opts},
+		{ImageName: "postgres:14", Options: opts},
+		{ImageName: "postgres:15", Options: opts},
+		{ImageName: "postgres:16", Options: opts},
+		{ImageName: "postgres:17", Options: opts},
+	}
+)
+
+func pgConnectionString(host, port string, options ...string) string {
+	options = append(options, "sslmode=disable")
+	return fmt.Sprintf("postgres://postgres:%s@%s:%s/postgres?%s", pgPassword, host, port, strings.Join(options, "&"))
+}
+
+func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
+	ip, port, err := c.FirstPort()
+	if err != nil {
+		return false
+	}
+
+	db, err := sql.Open("pgx", pgConnectionString(ip, port))
+	if err != nil {
+		return false
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			log.Println("close error:", err)
+		}
+	}()
+	if err = db.PingContext(ctx); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn, io.EOF:
+			return false
+		default:
+			log.Println(err)
+		}
+		return false
+	}
+
+	return true
+}
+
+func mustRun(t *testing.T, d database.Driver, statements []string) {
+	for _, statement := range statements {
+		if err := d.Run(strings.NewReader(statement)); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func Test(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		dt.Test(t, d, []byte("SELECT 1"))
+	})
+}
+
+func TestMigrate(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		m, err := migrate.NewWithDatabaseInstance("file://../examples/migrations", "pgx", d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+	})
+}
+
+func TestMultipleStatements(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if err := d.Run(strings.NewReader("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).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 {
+			t.Fatalf("expected table bar to exist")
+		}
+	})
+}
+
+func TestMultipleStatementsInMultiStatementMode(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-multi-statement=true")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if err := d.Run(strings.NewReader("CREATE TABLE foo (foo text); CREATE INDEX CONCURRENTLY idx_foo ON foo (foo);")); err != nil {
+			t.Fatalf("expected err to be nil, got %v", err)
+		}
+
+		// make sure created index exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM pg_indexes WHERE schemaname = (SELECT current_schema()) AND indexname = 'idx_foo')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table bar to exist")
+		}
+	})
+}
+
+func TestErrorParsing(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		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: ERROR: syntax error at or near "TABLEE" (SQLSTATE 42601))`
+		if err := d.Run(strings.NewReader("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) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-custom=foobar")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+	})
+}
+
+func TestWithSchema(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		// create foobar schema
+		if err := d.Run(strings.NewReader("CREATE SCHEMA foobar AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+		if err := d.SetVersion(1, false); err != nil {
+			t.Fatal(err)
+		}
+
+		// re-connect using that schema
+		d2, err := p.Open(pgConnectionString(ip, port, "search_path=foobar"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d2.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		version, _, err := d2.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != database.NilVersion {
+			t.Fatal("expected NilVersion")
+		}
+
+		// now update version and compare
+		if err := d2.SetVersion(2, false); err != nil {
+			t.Fatal(err)
+		}
+		version, _, err = d2.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != 2 {
+			t.Fatal("expected version 2")
+		}
+
+		// meanwhile, the public schema still has the other version
+		version, _, err = d.Version()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != 1 {
+			t.Fatal("expected version 2")
+		}
+	})
+}
+
+func TestMigrationTableOption(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, _ := p.Open(addr)
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		// create migrate schema
+		if err := d.Run(strings.NewReader("CREATE SCHEMA migrate AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+
+		// bad unquoted x-migrations-table parameter
+		wantErr := "x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: migrate.schema_migrations"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// too many quoted x-migrations-table parameters
+		wantErr = "\"\"migrate\".\"schema_migrations\".\"toomany\"\" MigrationsTable contains too many dot characters"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\".\"toomany\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// good quoted x-migrations-table parameter
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// make sure migrate.schema_migrations table exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'schema_migrations' AND table_schema = 'migrate')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table migrate.schema_migrations to exist")
+		}
+
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'migrate.schema_migrations' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table 'migrate.schema_migrations' to exist")
+		}
+
+	})
+}
+
+func TestFailToCreateTableWithoutPermissions(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		defer func() {
+			if d2 == nil {
+				return
+			}
+			if err := d2.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		var e *database.Error
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+
+		// re-connect using that x-migrations-table and x-migrations-table-quoted
+		d2, err = p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"barfoo\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+	})
+}
+
+func TestCheckBeforeCreateTable(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"GRANT CREATE ON SCHEMA barfoo TO not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := d2.Close(); err != nil {
+			t.Fatal(err)
+		}
+
+		// revoke privileges
+		mustRun(t, d, []string{
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d3, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		version, _, err := d3.Version()
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if version != database.NilVersion {
+			t.Fatal("Unexpected version, want database.NilVersion. Got: ", version)
+		}
+
+		defer func() {
+			if err := d3.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+	})
+}
+
+func TestParallelSchema(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create foo and bar schemas
+		if err := d.Run(strings.NewReader("CREATE SCHEMA foo AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+		if err := d.Run(strings.NewReader("CREATE SCHEMA bar AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+
+		// re-connect using that schemas
+		dfoo, err := p.Open(pgConnectionString(ip, port, "search_path=foo"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := dfoo.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		dbar, err := p.Open(pgConnectionString(ip, port, "search_path=bar"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := dbar.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		if err := dfoo.Lock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dbar.Lock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dbar.Unlock(); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := dfoo.Unlock(); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
+
+func TestPostgres_Lock(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(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 TestWithInstance_Concurrent(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// The number of concurrent processes running WithInstance
+		const concurrency = 30
+
+		// We can instantiate a single database handle because it is
+		// actually a connection pool, and so, each of the below go
+		// routines will have a high probability of using a separate
+		// connection, which is something we want to exercise.
+		db, err := sql.Open("pgx", pgConnectionString(ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		db.SetMaxIdleConns(concurrency)
+		db.SetMaxOpenConns(concurrency)
+
+		var wg sync.WaitGroup
+		defer wg.Wait()
+
+		wg.Add(concurrency)
+		for i := 0; i < concurrency; i++ {
+			go func(i int) {
+				defer wg.Done()
+				_, err := WithInstance(db, &Config{})
+				if err != nil {
+					t.Errorf("process %d error: %s", i, err)
+				}
+			}(i)
+		}
+	})
+}
+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.ReplaceAll(input, "\n", "\r\n")
+					}
+					if nonASCII {
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
+					}
+					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)
+		})
+	}
+}
@@ -5,7 +5,10 @@
 | URL Query  | WithInstance Config | Description |
 |------------|---------------------|-------------|
 | `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `x-migrations-table-quoted` | `MigrationsTableQuoted` | By default, migrate quotes the migration table for SQL injection safety reasons. This option disable quoting and naively checks that you have quoted the migration table name. e.g. `"my_schema"."schema_migrations"` |
 | `x-statement-timeout` | `StatementTimeout` | Abort any statement that takes more than the specified number of milliseconds |
+| `x-multi-statement` | `MultiStatementEnabled` | Enable multi-statement execution (default: false) |
+| `x-multi-statement-max-size` | `MultiStatementMaxSize` | Maximum size of single statement in bytes (default: 10MB) |
 | `dbname` | `DatabaseName` | The name of the database to connect to |
 | `search_path` | | This variable specifies the order in which schemas are searched when an object is referenced by a simple name with no schema specified. |
 | `user` | | The user to sign in as |
@@ -27,3 +30,10 @@
 2. Wrap your existing migrations in transactions ([BEGIN/COMMIT](https://www.postgresql.org/docs/current/static/transaction-iso.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>`.
+
+## Multi-statement mode
+
+In PostgreSQL running multiple SQL statements in one `Exec` executes them inside a transaction. Sometimes this
+behavior is not desirable because some statements can be only run outside of transaction (e.g.
+`CREATE INDEX CONCURRENTLY`). If you want to use `CREATE INDEX CONCURRENTLY` without activating multi-statement mode
+you have to put such statements in a separate migration files.
@@ -7,7 +7,7 @@ Our user here is `postgres`, password `password`, and host is `localhost`.
 ```
 psql -h localhost -U postgres -w -c "create database example;"
 ```
-When using Migrate CLI we need to pass to database URL. Let's export it to a variable for convienience:
+When using Migrate CLI we need to pass to database URL. Let's export it to a variable for convenience:
 ```
 export POSTGRESQL_URL='postgres://postgres:password@localhost:5432/example?sslmode=disable'
 ```
@@ -27,7 +27,7 @@ If there were no errors, we should have two files available under `db/migrations
 Note the `sql` extension that we provided.

 In the `.up.sql` file let's create the table:
-```
+```sql
 CREATE TABLE IF NOT EXISTS users(
   user_id serial PRIMARY KEY,
   username VARCHAR (50) UNIQUE NOT NULL,
@@ -36,7 +36,7 @@ CREATE TABLE IF NOT EXISTS users(
 );
 ```
 And in the `.down.sql` let's delete it:
-```
+```sql
 DROP TABLE IF EXISTS users;
 ```
 By adding `IF EXISTS/IF NOT EXISTS` we are making migrations idempotent - you can read more about idempotency in [getting started](../../GETTING_STARTED.md#create-migrations)
@@ -79,7 +79,7 @@ Again, it should create for us two migrations files:
 In Postgres, when we want our queries to be done in a transaction, we need to wrap it with `BEGIN` and `COMMIT` commands.
 In our example, we are going to add a column to our database that can only accept enumerable values or NULL.
 Migration up:
-```
+```sql
 BEGIN;

 CREATE TYPE enum_mood AS ENUM (
@@ -92,7 +92,7 @@ ALTER TABLE users ADD COLUMN mood enum_mood;
 COMMIT;
 ```
 Migration down:
-```
+```sql
 BEGIN;

 ALTER TABLE users DROP COLUMN mood;
@@ -124,7 +124,7 @@ Indexes:

 ## Optional: Run migrations within your Go app
 Here is a very simple app running migrations for the above configuration:
-```
+```go
 import (
 	"log"

@@ -146,3 +146,22 @@ func main() {
 }
 ```
 You can find details [here](README.md#use-in-your-go-project)
+
+## Fix issue where migrations run twice
+
+When the schema and role names are the same, you might run into issues if you create this schema using migrations.
+This is caused by the fact that the [default `search_path`](https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-PATH) is `"$user", public`.
+In the first run (with an empty database) the migrate table is created in `public`.
+When the migrations create the `$user` schema, the next run will store (a new) migrate table in this schema (due to order of schemas in `search_path`) and tries to apply all migrations again (most likely failing).
+
+To solve this you need to change the default `search_path` by removing the `$user` component, so the migrate table is always stored in the (available) `public` schema.
+This can be done using the [`search_path` query parameter in the URL](https://github.com/jexia/migrate/blob/fix-postgres-version-table/database/postgres/README.md#postgres).
+
+For example to force the migrations table in the public schema you can use:
+```
+export POSTGRESQL_URL='postgres://postgres:password@localhost:5432/example?sslmode=disable&search_path=public'
+```
+
+Note that you need to explicitly add the schema names to the table names in your migrations when you to modify the tables of the non-public schema.
+
+Alternatively you can add the non-public schema manually (before applying the migrations) if that is possible in your case and let the tool store the migrations table in this schema as well.
@@ -1,21 +1,23 @@
-// +build go1.9
+//go:build go1.9

 package postgres

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
+	"regexp"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"

 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	multierror "github.com/hashicorp/go-multierror"
+	"github.com/golang-migrate/migrate/v4/database/multistmt"
 	"github.com/lib/pq"
 )

@@ -25,7 +27,12 @@ func init() {
 	database.Register("postgresql", &db)
 }

-var DefaultMigrationsTable = "schema_migrations"
+var (
+	multiStmtDelimiter = []byte(";")
+
+	DefaultMigrationsTable       = "schema_migrations"
+	DefaultMultiStatementMaxSize = 10 * 1 << 20 // 10 MB
+)

 var (
 	ErrNilConfig      = fmt.Errorf("no config")
@@ -35,35 +42,40 @@ var (
 )

 type Config struct {
-	MigrationsTable  string
-	DatabaseName     string
-	SchemaName       string
-	StatementTimeout time.Duration
+	MigrationsTable       string
+	MigrationsTableQuoted bool
+	MultiStatementEnabled bool
+	DatabaseName          string
+	SchemaName            string
+	migrationsSchemaName  string
+	migrationsTableName   string
+	StatementTimeout      time.Duration
+	MultiStatementMaxSize int
 }

 type Postgres struct {
 	// Locking and unlocking need to use the same connection
 	conn     *sql.Conn
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	// Open and WithInstance need to guarantee that config is never nil
 	config *Config
 }

-func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+func WithConnection(ctx context.Context, conn *sql.Conn, config *Config) (*Postgres, error) {
 	if config == nil {
 		return nil, ErrNilConfig
 	}

-	if err := instance.Ping(); err != nil {
+	if err := conn.PingContext(ctx); err != nil {
 		return nil, err
 	}

 	if config.DatabaseName == "" {
 		query := `SELECT CURRENT_DATABASE()`
 		var databaseName string
-		if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		if err := conn.QueryRowContext(ctx, query).Scan(&databaseName); err != nil {
 			return nil, &database.Error{OrigErr: err, Query: []byte(query)}
 		}

@@ -76,31 +88,37 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {

 	if config.SchemaName == "" {
 		query := `SELECT CURRENT_SCHEMA()`
-		var schemaName string
-		if err := instance.QueryRow(query).Scan(&schemaName); err != nil {
+		var schemaName sql.NullString
+		if err := conn.QueryRowContext(ctx, query).Scan(&schemaName); err != nil {
 			return nil, &database.Error{OrigErr: err, Query: []byte(query)}
 		}

-		if len(schemaName) == 0 {
+		if !schemaName.Valid {
 			return nil, ErrNoSchema
 		}

-		config.SchemaName = schemaName
+		config.SchemaName = schemaName.String
 	}

 	if len(config.MigrationsTable) == 0 {
 		config.MigrationsTable = DefaultMigrationsTable
 	}

-	conn, err := instance.Conn(context.Background())
-
-	if err != nil {
-		return nil, err
+	config.migrationsSchemaName = config.SchemaName
+	config.migrationsTableName = config.MigrationsTable
+	if config.MigrationsTableQuoted {
+		re := regexp.MustCompile(`"(.*?)"`)
+		result := re.FindAllStringSubmatch(config.MigrationsTable, -1)
+		config.migrationsTableName = result[len(result)-1][1]
+		if len(result) == 2 {
+			config.migrationsSchemaName = result[0][1]
+		} else if len(result) > 2 {
+			return nil, fmt.Errorf("\"%s\" MigrationsTable contains too many dot characters", config.MigrationsTable)
+		}
 	}

 	px := &Postgres{
 		conn:   conn,
-		db:     instance,
 		config: config,
 	}

@@ -111,6 +129,26 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
 	return px, nil
 }

+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	ctx := context.Background()
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+
+	conn, err := instance.Conn(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	px, err := WithConnection(ctx, conn, config)
+	if err != nil {
+		return nil, err
+	}
+	px.db = instance
+	return px, nil
+}
+
 func (p *Postgres) Open(url string) (database.Driver, error) {
 	purl, err := nurl.Parse(url)
 	if err != nil {
@@ -123,6 +161,17 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	}

 	migrationsTable := purl.Query().Get("x-migrations-table")
+	migrationsTableQuoted := false
+	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
+		migrationsTableQuoted, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
+		}
+	}
+	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
+		return nil, fmt.Errorf("x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: %s", migrationsTable)
+	}
+
 	statementTimeoutString := purl.Query().Get("x-statement-timeout")
 	statementTimeout := 0
 	if statementTimeoutString != "" {
@@ -132,10 +181,32 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 		}
 	}

+	multiStatementMaxSize := DefaultMultiStatementMaxSize
+	if s := purl.Query().Get("x-multi-statement-max-size"); len(s) > 0 {
+		multiStatementMaxSize, err = strconv.Atoi(s)
+		if err != nil {
+			return nil, err
+		}
+		if multiStatementMaxSize <= 0 {
+			multiStatementMaxSize = DefaultMultiStatementMaxSize
+		}
+	}
+
+	multiStatementEnabled := false
+	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
+		multiStatementEnabled, err = strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
+		}
+	}
+
 	px, err := WithInstance(db, &Config{
-		DatabaseName:     purl.Path,
-		MigrationsTable:  migrationsTable,
-		StatementTimeout: time.Duration(statementTimeout) * time.Millisecond,
+		DatabaseName:          purl.Path,
+		MigrationsTable:       migrationsTable,
+		MigrationsTableQuoted: migrationsTableQuoted,
+		StatementTimeout:      time.Duration(statementTimeout) * time.Millisecond,
+		MultiStatementEnabled: multiStatementEnabled,
+		MultiStatementMaxSize: multiStatementMaxSize,
 	})

 	if err != nil {
@@ -147,7 +218,11 @@ func (p *Postgres) Open(url string) (database.Driver, error) {

 func (p *Postgres) Close() error {
 	connErr := p.conn.Close()
-	dbErr := p.db.Close()
+	var dbErr error
+	if p.db != nil {
+		dbErr = p.db.Close()
+	}
+
 	if connErr != nil || dbErr != nil {
 		return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)
 	}
@@ -156,56 +231,68 @@ func (p *Postgres) Close() error {

 // https://www.postgresql.org/docs/9.6/static/explicit-locking.html#ADVISORY-LOCKS
 func (p *Postgres) Lock() error {
-	if p.isLocked {
-		return database.ErrLocked
-	}
+	return database.CasRestoreOnErr(&p.isLocked, false, true, database.ErrLocked, func() error {
+		aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+		if err != nil {
+			return err
+		}

-	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.SchemaName)
-	if err != nil {
-		return err
-	}
+		// This will wait indefinitely until the lock can be acquired.
+		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)}
+		}

-	// This will wait indefinitely until the lock can be acquired.
-	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)}
-	}
-
-	p.isLocked = true
-	return nil
+		return nil
+	})
 }

 func (p *Postgres) Unlock() error {
-	if !p.isLocked {
+	return database.CasRestoreOnErr(&p.isLocked, true, false, database.ErrNotLocked, func() error {
+		aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.migrationsSchemaName, p.config.migrationsTableName)
+		if err != nil {
+			return err
+		}
+
+		query := `SELECT pg_advisory_unlock($1)`
+		if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
 		return nil
-	}
-
-	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName, p.config.SchemaName)
-	if err != nil {
-		return err
-	}
-
-	query := `SELECT pg_advisory_unlock($1)`
-	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
-		return &database.Error{OrigErr: err, Query: []byte(query)}
-	}
-	p.isLocked = false
-	return nil
+	})
 }

 func (p *Postgres) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	if p.config.MultiStatementEnabled {
+		var err error
+		if e := multistmt.Parse(migration, multiStmtDelimiter, p.config.MultiStatementMaxSize, func(m []byte) bool {
+			if err = p.runStatement(m); err != nil {
+				return false
+			}
+			return true
+		}); e != nil {
+			return e
+		}
+		return err
+	}
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
+	return p.runStatement(migr)
+}
+
+func (p *Postgres) runStatement(statement []byte) error {
 	ctx := context.Background()
 	if p.config.StatementTimeout != 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, p.config.StatementTimeout)
 		defer cancel()
 	}
-	// run migration
-	query := string(migr[:])
+	query := string(statement)
+	if strings.TrimSpace(query) == "" {
+		return nil
+	}
 	if _, err := p.conn.ExecContext(ctx, query); err != nil {
 		if pgErr, ok := err.(*pq.Error); ok {
 			var line uint
@@ -223,17 +310,16 @@ func (p *Postgres) Run(migration io.Reader) error {
 			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: message, Query: statement, Line: line}
 		}
-		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+		return database.Error{OrigErr: err, Err: "migration failed", Query: statement}
 	}
-
 	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)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// 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) {
@@ -272,10 +358,10 @@ func (p *Postgres) SetVersion(version int, dirty bool) error {
 		return &database.Error{OrigErr: err, Err: "transaction start failed"}
 	}

-	query := `TRUNCATE ` + pq.QuoteIdentifier(p.config.MigrationsTable)
+	query := `TRUNCATE ` + pq.QuoteIdentifier(p.config.migrationsSchemaName) + `.` + pq.QuoteIdentifier(p.config.migrationsTableName)
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -284,11 +370,10 @@ func (p *Postgres) SetVersion(version int, dirty bool) error {
 	// empty schema version for failed down migration on the first migration
 	// See: https://github.com/golang-migrate/migrate/issues/330
 	if version >= 0 || (version == database.NilVersion && dirty) {
-		query = `INSERT INTO ` + pq.QuoteIdentifier(p.config.MigrationsTable) +
-			` (version, dirty) VALUES ($1, $2)`
+		query = `INSERT INTO ` + pq.QuoteIdentifier(p.config.migrationsSchemaName) + `.` + pq.QuoteIdentifier(p.config.migrationsTableName) + ` (version, dirty) VALUES ($1, $2)`
 		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -302,7 +387,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 ` + pq.QuoteIdentifier(p.config.MigrationsTable) + ` LIMIT 1`
+	query := `SELECT version, dirty FROM ` + pq.QuoteIdentifier(p.config.migrationsSchemaName) + `.` + pq.QuoteIdentifier(p.config.migrationsTableName) + ` LIMIT 1`
 	err = p.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
 	switch {
 	case err == sql.ErrNoRows:
@@ -330,7 +415,7 @@ func (p *Postgres) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -345,6 +430,9 @@ func (p *Postgres) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	if len(tableNames) > 0 {
 		// delete one by one ...
@@ -369,15 +457,28 @@ func (p *Postgres) ensureVersionTable() (err error) {

 	defer func() {
 		if e := p.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

-	query := `CREATE TABLE IF NOT EXISTS ` + pq.QuoteIdentifier(p.config.MigrationsTable) + ` (version bigint not null primary key, dirty boolean not null)`
+	// This block checks whether the `MigrationsTable` already exists. This is useful because it allows read only postgres
+	// users to also check the current version of the schema. Previously, even if `MigrationsTable` existed, the
+	// `CREATE TABLE IF NOT EXISTS...` query would fail because the user does not have the CREATE permission.
+	// Taken from https://github.com/mattes/migrate/blob/master/database/postgres/postgres.go#L258
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2 LIMIT 1`
+	row := p.conn.QueryRowContext(context.Background(), query, p.config.migrationsSchemaName, p.config.migrationsTableName)
+
+	var count int
+	err = row.Scan(&count)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if count == 1 {
+		return nil
+	}
+
+	query = `CREATE TABLE IF NOT EXISTS ` + pq.QuoteIdentifier(p.config.migrationsSchemaName) + `.` + pq.QuoteIdentifier(p.config.migrationsTableName) + ` (version bigint not null primary key, dirty boolean not null)`
 	if _, err = p.conn.ExecContext(context.Background(), query); err != nil {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -6,16 +6,17 @@ import (
 	"context"
 	"database/sql"
 	sqldriver "database/sql/driver"
+	"errors"
 	"fmt"
-	"log"
-
-	"github.com/golang-migrate/migrate/v4"
 	"io"
+	"log"
 	"strconv"
 	"strings"
 	"sync"
 	"testing"

+	"github.com/golang-migrate/migrate/v4"
+
 	"github.com/dhui/dktest"

 	"github.com/golang-migrate/migrate/v4/database"
@@ -34,16 +35,17 @@ var (
 		PortRequired: true, ReadyFunc: isReady}
 	// Supported versions: https://www.postgresql.org/support/versioning/
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "postgres:9.5", Options: opts},
-		{ImageName: "postgres:9.6", Options: opts},
-		{ImageName: "postgres:10", Options: opts},
-		{ImageName: "postgres:11", Options: opts},
-		{ImageName: "postgres:12", Options: opts},
+		{ImageName: "postgres:13", Options: opts},
+		{ImageName: "postgres:14", Options: opts},
+		{ImageName: "postgres:15", Options: opts},
+		{ImageName: "postgres:16", Options: opts},
+		{ImageName: "postgres:17", Options: opts},
 	}
 )

-func pgConnectionString(host, port string) string {
-	return fmt.Sprintf("postgres://postgres:%s@%s:%s/postgres?sslmode=disable", pgPassword, host, port)
+func pgConnectionString(host, port string, options ...string) string {
+	options = append(options, "sslmode=disable")
+	return fmt.Sprintf("postgres://postgres:%s@%s:%s/postgres?%s", pgPassword, host, port, strings.Join(options, "&"))
 }

 func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
@@ -74,7 +76,41 @@ func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
 	return true
 }

+func mustRun(t *testing.T, d database.Driver, statements []string) {
+	for _, statement := range statements {
+		if err := d.Run(strings.NewReader(statement)); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
 func Test(t *testing.T) {
+	t.Run("test", test)
+	t.Run("testMigrate", testMigrate)
+	t.Run("testMultipleStatements", testMultipleStatements)
+	t.Run("testMultipleStatementsInMultiStatementMode", testMultipleStatementsInMultiStatementMode)
+	t.Run("testErrorParsing", testErrorParsing)
+	t.Run("testFilterCustomQuery", testFilterCustomQuery)
+	t.Run("testWithSchema", testWithSchema)
+	t.Run("testMigrationTableOption", testMigrationTableOption)
+	t.Run("testFailToCreateTableWithoutPermissions", testFailToCreateTableWithoutPermissions)
+	t.Run("testCheckBeforeCreateTable", testCheckBeforeCreateTable)
+	t.Run("testParallelSchema", testParallelSchema)
+	t.Run("testPostgresLock", testPostgresLock)
+	t.Run("testWithInstanceConcurrent", testWithInstanceConcurrent)
+	t.Run("testWithConnection", testWithConnection)
+
+	t.Cleanup(func() {
+		for _, spec := range specs {
+			t.Log("Cleaning up ", spec.ImageName)
+			if err := spec.Cleanup(); err != nil {
+				t.Error("Error removing ", spec.ImageName, "error:", err)
+			}
+		}
+	})
+}
+
+func test(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -96,7 +132,7 @@ func Test(t *testing.T) {
 	})
 }

-func TestMigrate(t *testing.T) {
+func testMigrate(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -122,7 +158,7 @@ func TestMigrate(t *testing.T) {
 	})
 }

-func TestMultiStatement(t *testing.T) {
+func testMultipleStatements(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -155,7 +191,40 @@ func TestMultiStatement(t *testing.T) {
 	})
 }

-func TestErrorParsing(t *testing.T) {
+func testMultipleStatementsInMultiStatementMode(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port, "x-multi-statement=true")
+		p := &Postgres{}
+		d, err := p.Open(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if err := d.Run(strings.NewReader("CREATE TABLE foo (foo text); CREATE INDEX CONCURRENTLY idx_foo ON foo (foo);")); err != nil {
+			t.Fatalf("expected err to be nil, got %v", err)
+		}
+
+		// make sure created index exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM pg_indexes WHERE schemaname = (SELECT current_schema()) AND indexname = 'idx_foo')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table bar to exist")
+		}
+	})
+}
+
+func testErrorParsing(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -184,7 +253,7 @@ func TestErrorParsing(t *testing.T) {
 	})
 }

-func TestFilterCustomQuery(t *testing.T) {
+func testFilterCustomQuery(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -206,7 +275,7 @@ func TestFilterCustomQuery(t *testing.T) {
 	})
 }

-func TestWithSchema(t *testing.T) {
+func testWithSchema(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -276,7 +345,222 @@ func TestWithSchema(t *testing.T) {
 	})
 }

-func TestParallelSchema(t *testing.T) {
+func testMigrationTableOption(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+		p := &Postgres{}
+		d, _ := p.Open(addr)
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		// create migrate schema
+		if err := d.Run(strings.NewReader("CREATE SCHEMA migrate AUTHORIZATION postgres")); err != nil {
+			t.Fatal(err)
+		}
+
+		// bad unquoted x-migrations-table parameter
+		wantErr := "x-migrations-table must be quoted (for instance '\"migrate\".\"schema_migrations\"') when x-migrations-table-quoted is enabled, current value is: migrate.schema_migrations"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// too many quoted x-migrations-table parameters
+		wantErr = "\"\"migrate\".\"schema_migrations\".\"toomany\"\" MigrationsTable contains too many dot characters"
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\".\"toomany\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if (err != nil) && (err.Error() != wantErr) {
+			t.Fatalf("expected '%s' but got '%s'", wantErr, err.Error())
+		}
+
+		// good quoted x-migrations-table parameter
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"migrate\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// make sure migrate.schema_migrations table exists
+		var exists bool
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'schema_migrations' AND table_schema = 'migrate')").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table migrate.schema_migrations to exist")
+		}
+
+		d, err = p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=migrate.schema_migrations",
+			pgPassword, ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'migrate.schema_migrations' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+			t.Fatal(err)
+		}
+		if !exists {
+			t.Fatalf("expected table 'migrate.schema_migrations' to exist")
+		}
+
+	})
+}
+
+func testFailToCreateTableWithoutPermissions(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		defer func() {
+			if d2 == nil {
+				return
+			}
+			if err := d2.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		var e *database.Error
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+
+		// re-connect using that x-migrations-table and x-migrations-table-quoted
+		d2, err = p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&x-migrations-table=\"barfoo\".\"schema_migrations\"&x-migrations-table-quoted=1",
+			pgPassword, ip, port))
+
+		if !errors.As(err, &e) || err == nil {
+			t.Fatal("Unexpected error, want permission denied error. Got: ", err)
+		}
+
+		if !strings.Contains(e.OrigErr.Error(), "permission denied for schema barfoo") {
+			t.Fatal(e)
+		}
+	})
+}
+
+func testCheckBeforeCreateTable(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addr := pgConnectionString(ip, port)
+
+		// Check that opening the postgres connection returns NilVersion
+		p := &Postgres{}
+
+		d, err := p.Open(addr)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := d.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		// create user who is not the owner. Although we're concatenating strings in an sql statement it should be fine
+		// since this is a test environment and we're not expecting to the pgPassword to be malicious
+		mustRun(t, d, []string{
+			"CREATE USER not_owner WITH ENCRYPTED PASSWORD '" + pgPassword + "'",
+			"CREATE SCHEMA barfoo AUTHORIZATION postgres",
+			"GRANT USAGE ON SCHEMA barfoo TO not_owner",
+			"GRANT CREATE ON SCHEMA barfoo TO not_owner",
+		})
+
+		// re-connect using that schema
+		d2, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := d2.Close(); err != nil {
+			t.Fatal(err)
+		}
+
+		// revoke privileges
+		mustRun(t, d, []string{
+			"REVOKE CREATE ON SCHEMA barfoo FROM PUBLIC",
+			"REVOKE CREATE ON SCHEMA barfoo FROM not_owner",
+		})
+
+		// re-connect using that schema
+		d3, err := p.Open(fmt.Sprintf("postgres://not_owner:%s@%v:%v/postgres?sslmode=disable&search_path=barfoo",
+			pgPassword, ip, port))
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		version, _, err := d3.Version()
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if version != database.NilVersion {
+			t.Fatal("Unexpected version, want database.NilVersion. Got: ", version)
+		}
+
+		defer func() {
+			if err := d3.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+	})
+}
+
+func testParallelSchema(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -344,11 +628,7 @@ func TestParallelSchema(t *testing.T) {
 	})
 }

-func TestWithInstance(t *testing.T) {
-
-}
-
-func TestPostgres_Lock(t *testing.T) {
+func testPostgresLock(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -388,7 +668,7 @@ func TestPostgres_Lock(t *testing.T) {
 	})
 }

-func TestWithInstance_Concurrent(t *testing.T) {
+func testWithInstanceConcurrent(t *testing.T) {
 	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
 		ip, port, err := c.FirstPort()
 		if err != nil {
@@ -430,6 +710,44 @@ func TestWithInstance_Concurrent(t *testing.T) {
 		}
 	})
 }
+
+func testWithConnection(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.FirstPort()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		db, err := sql.Open("postgres", pgConnectionString(ip, port))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+
+		ctx := context.Background()
+		conn, err := db.Conn(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		p, err := WithConnection(ctx, conn, &Config{})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defer func() {
+			if err := p.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		dt.Test(t, p, []byte("SELECT 1"))
+	})
+}
+
 func Test_computeLineFromPos(t *testing.T) {
 	testcases := []struct {
 		pos      int
@@ -480,10 +798,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)

@@ -508,5 +826,4 @@ func Test_computeLineFromPos(t *testing.T) {
 			run(true, true)
 		})
 	}
-
 }
@@ -2,13 +2,12 @@ package ql

 import (
 	"database/sql"
+	"errors"
 	"fmt"
-	"github.com/hashicorp/go-multierror"
 	"io"
-	"io/ioutil"
-	"strings"
-
 	nurl "net/url"
+	"strings"
+	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
@@ -34,7 +33,7 @@ type Config struct {

 type Ql struct {
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	config *Config
 }
@@ -72,11 +71,7 @@ func (m *Ql) ensureVersionTable() (err error) {

 	defer func() {
 		if e := m.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -133,9 +128,10 @@ func (m *Ql) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()
+
 	tableNames := make([]string, 0)
 	for tables.Next() {
 		var tableName string
@@ -148,6 +144,10 @@ func (m *Ql) Drop() (err error) {
 			}
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
 	if len(tableNames) > 0 {
 		for _, t := range tableNames {
 			query := "DROP TABLE " + t
@@ -161,21 +161,19 @@ func (m *Ql) Drop() (err error) {
 	return nil
 }
 func (m *Ql) Lock() error {
-	if m.isLocked {
+	if !m.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	m.isLocked = true
 	return nil
 }
 func (m *Ql) Unlock() error {
-	if !m.isLocked {
-		return nil
+	if !m.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
 	}
-	m.isLocked = false
 	return nil
 }
 func (m *Ql) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -190,7 +188,7 @@ func (m *Ql) executeQuery(query string) error {
 	}
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -218,7 +216,7 @@ func (m *Ql) SetVersion(version int, dirty bool) error {
 			m.config.MigrationsTable)
 		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -3,8 +3,6 @@ package ql
 import (
 	"database/sql"
 	"fmt"
-	"io/ioutil"
-	"os"
 	"path/filepath"
 	"testing"

@@ -15,15 +13,7 @@ import (
 )

 func Test(t *testing.T) {
-	dir, err := ioutil.TempDir("", "ql-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Fatal(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "ql.db"))
 	p := &Ql{}
 	addr := fmt.Sprintf("ql://%s", filepath.Join(dir, "ql.db"))
@@ -45,15 +35,7 @@ func Test(t *testing.T) {
 }

 func TestMigrate(t *testing.T) {
-	dir, err := ioutil.TempDir("", "ql-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "ql.db"))

 	db, err := sql.Open("ql", filepath.Join(dir, "ql.db"))
@@ -1,20 +1,20 @@
-// +build go1.9
+//go:build go1.9

 package redshift

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"strconv"
 	"strings"
+	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	"github.com/lib/pq"
 )

@@ -36,7 +36,7 @@ type Config struct {
 }

 type Redshift struct {
-	isLocked bool
+	isLocked atomic.Bool
 	conn     *sql.Conn
 	db       *sql.DB

@@ -126,20 +126,21 @@ func (p *Redshift) Close() error {

 // Redshift does not support advisory lock functions: https://docs.aws.amazon.com/redshift/latest/dg/c_unsupported-postgresql-functions.html
 func (p *Redshift) Lock() error {
-	if p.isLocked {
+	if !p.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	p.isLocked = true
 	return nil
 }

 func (p *Redshift) Unlock() error {
-	p.isLocked = false
+	if !p.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
 	return nil
 }

 func (p *Redshift) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -173,7 +174,7 @@ func (p *Redshift) Run(migration io.Reader) error {

 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// 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) {
@@ -215,7 +216,7 @@ func (p *Redshift) SetVersion(version int, dirty bool) error {
 	query := `DELETE FROM "` + p.config.MigrationsTable + `"`
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -227,7 +228,7 @@ func (p *Redshift) SetVersion(version int, dirty bool) error {
 		query = `INSERT INTO "` + p.config.MigrationsTable + `" (version, dirty) VALUES ($1, $2)`
 		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -269,7 +270,7 @@ func (p *Redshift) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -284,6 +285,9 @@ func (p *Redshift) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	if len(tableNames) > 0 {
 		// delete one by one ...
@@ -308,11 +312,7 @@ func (p *Redshift) ensureVersionTable() (err error) {

 	defer func() {
 		if e := p.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -28,10 +28,19 @@ import (
 	_ "github.com/golang-migrate/migrate/v4/source/file"
 )

+const (
+	pgPassword = "redshift"
+)
+
 var (
-	opts  = dktest.Options{PortRequired: true, ReadyFunc: isReady}
+	opts = dktest.Options{
+		Env:          map[string]string{"POSTGRES_PASSWORD": pgPassword},
+		PortRequired: true,
+		ReadyFunc:    isReady,
+	}
+
 	specs = []dktesting.ContainerSpec{
-		{ImageName: "postgres:8", Options: opts},
+		{ImageName: "migrate/postgres8:8", Options: opts},
 	}
 )

@@ -44,7 +53,7 @@ func pgConnectionString(host, port string) string {
 }

 func connectionString(schema, host, port string) string {
-	return fmt.Sprintf("%s://postgres@%s:%s/postgres?sslmode=disable", schema, host, port)
+	return fmt.Sprintf("%s://postgres:%s@%s:%s/postgres?sslmode=disable", schema, pgPassword, host, port)
 }

 func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
@@ -192,7 +201,7 @@ func TestFilterCustomQuery(t *testing.T) {
 			t.Fatal(err)
 		}

-		addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable&x-custom=foobar", ip, port)
+		addr := fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&x-custom=foobar", pgPassword, ip, port)
 		p := &Redshift{}
 		d, err := p.Open(addr)
 		if err != nil {
@@ -234,7 +243,7 @@ func TestWithSchema(t *testing.T) {
 		}

 		// re-connect using that schema
-		d2, err := p.Open(fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable&search_path=foobar", ip, port))
+		d2, err := p.Open(fmt.Sprintf("postgres://postgres:%s@%v:%v/postgres?sslmode=disable&search_path=foobar", pgPassword, ip, port))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -369,10 +378,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)

@@ -0,0 +1,18 @@
+# rqlite
+
+`rqlite://admin:secret@server1.example.com:4001/?level=strong&timeout=5`
+
+The `rqlite` url scheme is used for both secure and insecure connections. If connecting to an insecure database, pass `x-connect-insecure` in your URL query, or use `WithInstance` to pass an established connection.
+
+The migrations table name is configurable through the `x-migrations-table` URL query parameter, or by using `WithInstance` and passing `MigrationsTable` through `Config`.
+
+Other connect parameters are directly passed through to the database driver. For examples of connection strings, see https://github.com/rqlite/gorqlite#examples.
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-connect-insecure` | n/a: set on instance | Boolean to indicate whether to use an insecure connection. Defaults to `false`. |
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table.  Defaults to `schema_migrations`. |
+
+## Notes
+
+* Uses the https://github.com/rqlite/gorqlite driver
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;
@@ -0,0 +1,3 @@
+CREATE TABLE pets (
+  name string
+);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;
@@ -0,0 +1 @@
+ALTER TABLE pets ADD predator bool;
@@ -0,0 +1,328 @@
+package rqlite
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	nurl "net/url"
+	"strconv"
+	"strings"
+	"sync/atomic"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/rqlite/gorqlite"
+)
+
+func init() {
+	database.Register("rqlite", &Rqlite{})
+}
+
+const (
+	// DefaultMigrationsTable defines the default rqlite migrations table
+	DefaultMigrationsTable = "schema_migrations"
+
+	// DefaultConnectInsecure defines the default setting for connect insecure
+	DefaultConnectInsecure = false
+)
+
+// ErrNilConfig is returned if no configuration was passed to WithInstance
+var ErrNilConfig = fmt.Errorf("no config")
+
+// ErrBadConfig is returned if configuration was invalid
+var ErrBadConfig = fmt.Errorf("bad parameter")
+
+// Config defines the driver configuration
+type Config struct {
+	// ConnectInsecure sets whether the connection uses TLS. Ineffectual when using WithInstance
+	ConnectInsecure bool
+	// MigrationsTable configures the migrations table name
+	MigrationsTable string
+}
+
+type Rqlite struct {
+	db       *gorqlite.Connection
+	isLocked atomic.Bool
+
+	config *Config
+}
+
+// WithInstance creates a rqlite database driver with an existing gorqlite database connection
+// and a Config struct
+func WithInstance(instance *gorqlite.Connection, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	// we use the consistency level check as a database ping
+	if _, err := instance.ConsistencyLevel(); err != nil {
+		return nil, err
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	driver := &Rqlite{
+		db:     instance,
+		config: config,
+	}
+
+	if err := driver.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return driver, nil
+}
+
+// OpenURL creates a rqlite database driver from a connect URL
+func OpenURL(url string) (database.Driver, error) {
+	d := &Rqlite{}
+	return d.Open(url)
+}
+
+func (r *Rqlite) ensureVersionTable() (err error) {
+	if err = r.Lock(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if e := r.Unlock(); e != nil {
+			err = errors.Join(err, e)
+		}
+	}()
+
+	stmts := []string{
+		fmt.Sprintf(`CREATE TABLE IF NOT EXISTS %s (version uint64, dirty bool)`, r.config.MigrationsTable),
+		fmt.Sprintf(`CREATE UNIQUE INDEX IF NOT EXISTS version_unique ON %s (version)`, r.config.MigrationsTable),
+	}
+
+	if _, err := r.db.Write(stmts); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Open returns a new driver instance configured with parameters
+// coming from the URL string. Migrate will call this function
+// only once per instance.
+func (r *Rqlite) Open(url string) (database.Driver, error) {
+	dburl, config, err := parseUrl(url)
+	if err != nil {
+		return nil, err
+	}
+	r.config = config
+
+	r.db, err = gorqlite.Open(dburl.String())
+	if err != nil {
+		return nil, err
+	}
+
+	if err := r.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+// Close closes the underlying database instance managed by the driver.
+// Migrate will call this function only once per instance.
+func (r *Rqlite) Close() error {
+	r.db.Close()
+	return nil
+}
+
+// Lock should acquire a database lock so that only one migration process
+// can run at a time. Migrate will call this function before Run is called.
+// If the implementation can't provide this functionality, return nil.
+// Return database.ErrLocked if database is already locked.
+func (r *Rqlite) Lock() error {
+	if !r.isLocked.CompareAndSwap(false, true) {
+		return database.ErrLocked
+	}
+	return nil
+}
+
+// Unlock should release the lock. Migrate will call this function after
+// all migrations have been run.
+func (r *Rqlite) Unlock() error {
+	if !r.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
+	return nil
+}
+
+// Run applies a migration to the database. migration is guaranteed to be not nil.
+func (r *Rqlite) Run(migration io.Reader) error {
+	migr, err := io.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	query := string(migr[:])
+	if _, err := r.db.WriteOne(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
+
+// SetVersion saves version and dirty state.
+// Migrate will call this function before and after each call to Run.
+// version must be >= -1. -1 means NilVersion.
+func (r *Rqlite) SetVersion(version int, dirty bool) error {
+	deleteQuery := fmt.Sprintf(`DELETE FROM %s`, r.config.MigrationsTable)
+	statements := []gorqlite.ParameterizedStatement{
+		{
+			Query: deleteQuery,
+		},
+	}
+
+	// Also re-write the schema version for nil dirty versions to prevent
+	// empty schema version for failed down migration on the first migration
+	// See: https://github.com/golang-migrate/migrate/issues/330
+	insertQuery := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, r.config.MigrationsTable)
+	if version >= 0 || (version == database.NilVersion && dirty) {
+		statements = append(statements, gorqlite.ParameterizedStatement{
+			Query: insertQuery,
+			Arguments: []interface{}{
+				version,
+				dirty,
+			},
+		})
+	}
+
+	wr, err := r.db.WriteParameterized(statements)
+	if err != nil {
+		for i, res := range wr {
+			if res.Err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(statements[i].Query)}
+			}
+		}
+
+		// if somehow we're still here, return the original error with combined queries
+		return &database.Error{OrigErr: err, Query: []byte(deleteQuery + "\n" + insertQuery)}
+	}
+
+	return nil
+}
+
+// Version returns the currently active version and if the database is dirty.
+// When no migration has been applied, it must return version -1.
+// Dirty means, a previous migration failed and user interaction is required.
+func (r *Rqlite) Version() (version int, dirty bool, err error) {
+	query := "SELECT version, dirty FROM " + r.config.MigrationsTable + " LIMIT 1"
+
+	qr, err := r.db.QueryOne(query)
+	if err != nil {
+		return database.NilVersion, false, nil
+	}
+
+	if !qr.Next() {
+		return database.NilVersion, false, nil
+	}
+
+	if err := qr.Scan(&version, &dirty); err != nil {
+		return database.NilVersion, false, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return version, dirty, nil
+}
+
+// Drop deletes everything in the database.
+// Note that this is a breaking action, a new call to Open() is necessary to
+// ensure subsequent calls work as expected.
+func (r *Rqlite) Drop() error {
+	query := `SELECT name FROM sqlite_master WHERE type = 'table'`
+
+	tables, err := r.db.QueryOne(query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	statements := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+
+		if len(tableName) > 0 {
+			statement := fmt.Sprintf(`DROP TABLE %s`, tableName)
+			statements = append(statements, statement)
+		}
+	}
+
+	// return if nothing to do
+	if len(statements) <= 0 {
+		return nil
+	}
+
+	wr, err := r.db.Write(statements)
+	if err != nil {
+		for i, res := range wr {
+			if res.Err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(statements[i])}
+			}
+		}
+
+		// if somehow we're still here, return the original error with combined queries
+		return &database.Error{OrigErr: err, Query: []byte(strings.Join(statements, "\n"))}
+	}
+
+	return nil
+}
+
+func parseUrl(url string) (*nurl.URL, *Config, error) {
+	parsedUrl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	config, err := parseConfigFromQuery(parsedUrl.Query())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if parsedUrl.Scheme != "rqlite" {
+		return nil, nil, fmt.Errorf("bad scheme: %w", ErrBadConfig)
+	}
+
+	// adapt from rqlite to http/https schemes
+	if config.ConnectInsecure {
+		parsedUrl.Scheme = "http"
+	} else {
+		parsedUrl.Scheme = "https"
+	}
+
+	filteredUrl := migrate.FilterCustomQuery(parsedUrl)
+
+	return filteredUrl, config, nil
+}
+
+func parseConfigFromQuery(queryVals nurl.Values) (*Config, error) {
+	c := Config{
+		ConnectInsecure: DefaultConnectInsecure,
+		MigrationsTable: DefaultMigrationsTable,
+	}
+
+	migrationsTable := queryVals.Get("x-migrations-table")
+	if migrationsTable != "" {
+		if strings.HasPrefix(migrationsTable, "sqlite_") {
+			return nil, fmt.Errorf("invalid value for x-migrations-table: %w", ErrBadConfig)
+		}
+		c.MigrationsTable = migrationsTable
+	}
+
+	connectInsecureStr := queryVals.Get("x-connect-insecure")
+	if connectInsecureStr != "" {
+		connectInsecure, err := strconv.ParseBool(connectInsecureStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid value for x-connect-insecure: %w", ErrBadConfig)
+		}
+		c.ConnectInsecure = connectInsecure
+	}
+
+	return &c, nil
+}
@@ -0,0 +1,324 @@
+package rqlite
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/dhui/dktest"
+	"github.com/rqlite/gorqlite"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/golang-migrate/migrate/v4"
+	dt "github.com/golang-migrate/migrate/v4/database/testing"
+	"github.com/golang-migrate/migrate/v4/dktesting"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+)
+
+var defaultPort uint16 = 4001
+
+var opts = dktest.Options{
+	Env:          map[string]string{"NODE_ID": "1"},
+	PortRequired: true,
+	ReadyFunc:    isReady,
+}
+var specs = []dktesting.ContainerSpec{
+	{ImageName: "rqlite/rqlite:7.21.4", Options: opts},
+	{ImageName: "rqlite/rqlite:8.0.6", Options: opts},
+	{ImageName: "rqlite/rqlite:8.11.1", Options: opts},
+	{ImageName: "rqlite/rqlite:8.12.3", Options: opts},
+}
+
+func isReady(ctx context.Context, c dktest.ContainerInfo) bool {
+	ip, port, err := c.Port(defaultPort)
+	if err != nil {
+		fmt.Println("error getting port")
+		return false
+	}
+
+	statusString := fmt.Sprintf("http://%s:%s/status", ip, port)
+	fmt.Println(statusString)
+
+	var readyResp struct {
+		Store struct {
+			Ready bool `json:"ready"`
+		} `json:"store"`
+	}
+
+	resp, err := http.Get(statusString)
+	if err != nil {
+		fmt.Println("error getting status")
+		return false
+	}
+
+	if resp.StatusCode != 200 {
+		fmt.Println("statusCode != 200")
+		return false
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Println("error reading body")
+		return false
+	}
+
+	if err := json.Unmarshal(body, &readyResp); err != nil {
+		fmt.Println("error unmarshaling body")
+		return false
+	}
+
+	return readyResp.Store.Ready
+}
+
+func Test(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		connectString := fmt.Sprintf("rqlite://%s:%s?level=strong&disableClusterDiscovery=true&x-connect-insecure=true", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+
+		r := &Rqlite{}
+		d, err := r.Open(connectString)
+		assert.NoError(t, err)
+
+		dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);"))
+	})
+}
+
+func TestMigrate(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		connectString := fmt.Sprintf("rqlite://%s:%s?level=strong&disableClusterDiscovery=true&x-connect-insecure=true", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+
+		driver, err := OpenURL(connectString)
+		assert.NoError(t, err)
+		defer func() {
+			if err := driver.Close(); err != nil {
+				return
+			}
+		}()
+
+		m, err := migrate.NewWithDatabaseInstance(
+			"file://./examples/migrations",
+			"ql", driver)
+		assert.NoError(t, err)
+
+		dt.TestMigrate(t, m)
+	})
+}
+
+func TestBadConnectInsecureParam(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		connectString := fmt.Sprintf("rqlite://%s:%s?x-connect-insecure=foo", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+
+		_, err = OpenURL(connectString)
+		assert.ErrorIs(t, err, ErrBadConfig)
+	})
+}
+
+func TestBadProtocol(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		connectString := fmt.Sprintf("postgres://%s:%s/database", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+
+		_, err = OpenURL(connectString)
+		assert.ErrorIs(t, err, ErrBadConfig)
+	})
+}
+
+func TestNoConfig(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		// gorqlite expects http(s) schemes
+		connectString := fmt.Sprintf("http://%s:%s?level=strong&disableClusterDiscovery=true", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+		db, err := gorqlite.Open(connectString)
+		assert.NoError(t, err)
+
+		_, err = WithInstance(db, nil)
+		assert.ErrorIs(t, err, ErrNilConfig)
+	})
+}
+
+func TestWithInstanceEmptyConfig(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		// gorqlite expects http(s) schemes
+		connectString := fmt.Sprintf("http://%s:%s?level=strong&disableClusterDiscovery=true", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+		db, err := gorqlite.Open(connectString)
+		assert.NoError(t, err)
+
+		driver, err := WithInstance(db, &Config{})
+		assert.NoError(t, err)
+
+		defer func() {
+			if err := driver.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		m, err := migrate.NewWithDatabaseInstance(
+			"file://./examples/migrations",
+			"ql", driver)
+		assert.NoError(t, err)
+
+		t.Log("UP")
+		err = m.Up()
+		assert.NoError(t, err)
+
+		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", DefaultMigrationsTable))
+		assert.NoError(t, err)
+
+		t.Log("DOWN")
+		err = m.Down()
+		assert.NoError(t, err)
+	})
+}
+
+func TestMigrationTable(t *testing.T) {
+	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
+		ip, port, err := c.Port(defaultPort)
+		assert.NoError(t, err)
+
+		// gorqlite expects http(s) schemes
+		connectString := fmt.Sprintf("http://%s:%s?level=strong&disableClusterDiscovery=true", ip, port)
+		t.Logf("DB connect string : %s\n", connectString)
+		db, err := gorqlite.Open(connectString)
+		assert.NoError(t, err)
+
+		config := Config{MigrationsTable: "my_migration_table"}
+		driver, err := WithInstance(db, &config)
+		assert.NoError(t, err)
+
+		defer func() {
+			if err := driver.Close(); err != nil {
+				t.Fatal(err)
+			}
+		}()
+
+		m, err := migrate.NewWithDatabaseInstance(
+			"file://./examples/migrations",
+			"ql", driver)
+		assert.NoError(t, err)
+
+		t.Log("UP")
+		err = m.Up()
+		assert.NoError(t, err)
+
+		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", config.MigrationsTable))
+		assert.NoError(t, err)
+
+		_, err = db.WriteOne(`INSERT INTO pets (name, predator) VALUES ("franklin", true)`)
+		assert.NoError(t, err)
+
+		res, err := db.QueryOne(`SELECT name, predator FROM pets LIMIT 1`)
+		assert.NoError(t, err)
+
+		_ = res.Next()
+
+		// make sure we can use the migrated table
+		var petName string
+		var petPredator int
+		err = res.Scan(&petName, &petPredator)
+		assert.NoError(t, err)
+		assert.Equal(t, petName, "franklin")
+		assert.Equal(t, petPredator, 1)
+
+		t.Log("DOWN")
+		err = m.Down()
+		assert.NoError(t, err)
+
+		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", config.MigrationsTable))
+		assert.NoError(t, err)
+	})
+}
+
+func TestParseUrl(t *testing.T) {
+	tests := []struct {
+		name           string
+		passedUrl      string
+		expectedUrl    string
+		expectedConfig *Config
+		expectedErr    string
+	}{
+		{
+			"defaults",
+			"rqlite://localhost:4001",
+			"https://localhost:4001",
+			&Config{ConnectInsecure: DefaultConnectInsecure, MigrationsTable: DefaultMigrationsTable},
+			"",
+		},
+		{
+			"configure migration table",
+			"rqlite://localhost:4001?x-migrations-table=foo",
+			"https://localhost:4001",
+			&Config{ConnectInsecure: DefaultConnectInsecure, MigrationsTable: "foo"},
+			"",
+		},
+		{
+			"configure connect insecure",
+			"rqlite://localhost:4001?x-connect-insecure=true",
+			"http://localhost:4001",
+			&Config{ConnectInsecure: true, MigrationsTable: DefaultMigrationsTable},
+			"",
+		},
+		{
+			"invalid migration table",
+			"rqlite://localhost:4001?x-migrations-table=sqlite_bar",
+			"",
+			nil,
+			"invalid value for x-migrations-table: bad parameter",
+		},
+		{
+			"invalid connect insecure",
+			"rqlite://localhost:4001?x-connect-insecure=baz",
+			"",
+			nil,
+			"invalid value for x-connect-insecure: bad parameter",
+		},
+		{
+			"invalid url",
+			string([]byte{0x7f}),
+			"",
+			nil,
+			"parse \"\\x7f\": net/url: invalid control character in URL",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actualUrl, actualConfig, actualErr := parseUrl(tt.passedUrl)
+			if tt.expectedUrl != "" {
+				assert.Equal(t, tt.expectedUrl, actualUrl.String())
+			} else {
+				assert.Nil(t, actualUrl)
+			}
+
+			assert.Equal(t, tt.expectedConfig, actualConfig)
+
+			if tt.expectedErr == "" {
+				assert.NoError(t, actualErr)
+			} else {
+				assert.EqualError(t, actualErr, tt.expectedErr)
+			}
+		})
+	}
+}
@@ -3,15 +3,15 @@ package snowflake
 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"strconv"
 	"strings"
+	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	"github.com/lib/pq"
 	sf "github.com/snowflakedb/gosnowflake"
 )
@@ -37,7 +37,7 @@ type Config struct {
 }

 type Snowflake struct {
-	isLocked bool
+	isLocked atomic.Bool
 	conn     *sql.Conn
 	db       *sql.DB

@@ -158,20 +158,21 @@ func (p *Snowflake) Close() error {
 }

 func (p *Snowflake) Lock() error {
-	if p.isLocked {
+	if !p.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	p.isLocked = true
 	return nil
 }

 func (p *Snowflake) Unlock() error {
-	p.isLocked = false
+	if !p.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
 	return nil
 }

 func (p *Snowflake) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -205,7 +206,7 @@ func (p *Snowflake) Run(migration io.Reader) error {

 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// 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) {
@@ -247,7 +248,7 @@ func (p *Snowflake) SetVersion(version int, dirty bool) error {
 	query := `DELETE FROM "` + p.config.MigrationsTable + `"`
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -261,7 +262,7 @@ func (p *Snowflake) SetVersion(version int, dirty bool) error {
 				` + strconv.FormatBool(dirty) + `)`
 		if _, err := tx.Exec(query); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -303,7 +304,7 @@ func (p *Snowflake) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()

@@ -318,6 +319,9 @@ func (p *Snowflake) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}

 	if len(tableNames) > 0 {
 		// delete one by one ...
@@ -342,11 +346,7 @@ func (p *Snowflake) ensureVersionTable() (err error) {

 	defer func() {
 		if e := p.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -33,7 +33,7 @@ as described in [README.md#database-urls](../../README.md#database-urls)
 ## DDL with comments

 At the moment the GCP Spanner backed does not seem to allow for comments (See https://issuetracker.google.com/issues/159730604)
-so in order to be able to use migration with DDL containing comments `x-clean-stamements` is required
+so in order to be able to use migration with DDL containing comments `x-clean-statements` is required

 ## Multiple statements

@@ -0,0 +1 @@
+DROP TABLE Transactions
@@ -0,0 +1,6 @@
+CREATE TABLE Transactions (
+  UserId        INT64,
+  TransactionId STRING(40),
+  Total         NUMERIC
+) PRIMARY KEY(UserId, TransactionId), 
+INTERLEAVE IN PARENT Users ON DELETE CASCADE
@@ -1,16 +1,16 @@
 package spanner

 import (
+	"context"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	nurl "net/url"
 	"regexp"
 	"strconv"
 	"strings"
-
-	"golang.org/x/net/context"
+	"sync/atomic"

 	"cloud.google.com/go/spanner"
 	sdb "cloud.google.com/go/spanner/admin/database/apiv1"
@@ -19,9 +19,8 @@ import (
 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"

-	"github.com/hashicorp/go-multierror"
+	adminpb "cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
 	"google.golang.org/api/iterator"
-	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
 )

 func init() {
@@ -34,10 +33,12 @@ 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")
+	ErrNilConfig      = errors.New("no config")
+	ErrNoDatabaseName = errors.New("no database name")
+	ErrNoSchema       = errors.New("no schema")
+	ErrDatabaseDirty  = errors.New("database is dirty")
+	ErrLockHeld       = errors.New("unable to obtain lock")
+	ErrLockNotHeld    = errors.New("unable to release already released lock")
 )

 // Config used for a Spanner instance
@@ -56,6 +57,8 @@ type Spanner struct {
 	db *DB

 	config *Config
+
+	lock atomic.Bool
 }

 type DB struct {
@@ -143,17 +146,23 @@ func (s *Spanner) Close() error {
 // Lock implements database.Driver but doesn't do anything because Spanner only
 // enqueues the UpdateDatabaseDdlRequest.
 func (s *Spanner) Lock() error {
-	return nil
+	if swapped := s.lock.CompareAndSwap(false, true); swapped {
+		return nil
+	}
+	return ErrLockHeld
 }

 // Unlock implements database.Driver but no action required, see Lock.
 func (s *Spanner) Unlock() error {
-	return nil
+	if swapped := s.lock.CompareAndSwap(true, false); swapped {
+		return nil
+	}
+	return ErrLockNotHeld
 }

 // Run implements database.Driver
 func (s *Spanner) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -289,11 +298,7 @@ func (s *Spanner) ensureVersionTable() (err error) {

 	defer func() {
 		if e := s.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -8,52 +8,57 @@ import (
 	"github.com/golang-migrate/migrate/v4"

 	dt "github.com/golang-migrate/migrate/v4/database/testing"
-
 	_ "github.com/golang-migrate/migrate/v4/source/file"
+
+	"cloud.google.com/go/spanner/spannertest"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

-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://%s", db)
-	d, err := s.Open(addr)
+// withSpannerEmulator is not thread-safe and cannot be used with parallel tests since it sets the emulator
+func withSpannerEmulator(t *testing.T, testFunc func(t *testing.T)) {
+	t.Helper()
+	srv, err := spannertest.NewServer("localhost:0")
 	if err != nil {
-		t.Fatal(err)
+		t.Fatal("Failed to create Spanner emulator:", err)
 	}
-	dt.Test(t, d, []byte("SELECT 1"))
+	// This is not thread-safe
+	if err := os.Setenv("SPANNER_EMULATOR_HOST", srv.Addr); err != nil {
+		t.Fatal("Failed to set SPANNER_EMULATOR_HOST env var:", err)
+	}
+	defer srv.Close()
+	testFunc(t)
+
+}
+
+const db = "projects/abc/instances/def/databases/testdb"
+
+func Test(t *testing.T) {
+	withSpannerEmulator(t, func(t *testing.T) {
+		uri := fmt.Sprintf("spanner://%s", db)
+		s := &Spanner{}
+		d, err := s.Open(uri)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.Test(t, d, []byte("CREATE TABLE test (id BOOL) PRIMARY KEY (id)"))
+	})
 }

 func TestMigrate(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://%s", db)
-	d, err := s.Open(addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", db, d)
-	if err != nil {
-		t.Fatal(err)
-	}
-	dt.TestMigrate(t, m)
+	withSpannerEmulator(t, func(t *testing.T) {
+		s := &Spanner{}
+		uri := fmt.Sprintf("spanner://%s", db)
+		d, err := s.Open(uri)
+		if err != nil {
+			t.Fatal(err)
+		}
+		m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", uri, d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dt.TestMigrate(t, m)
+	})
 }

 func TestCleanStatements(t *testing.T) {
@@ -146,6 +151,14 @@ func TestCleanStatements(t *testing.T) {
 			SET OPTIONS (allow_commit_timestamp=true);`,
 			expected: []string{"ALTER TABLE users ALTER COLUMN created SET OPTIONS (allow_commit_timestamp = true)"},
 		},
+		{
+			name: "column with NUMERIC type",
+			multiStatement: `CREATE TABLE table_name (
+				id STRING(255) NOT NULL,
+				sum NUMERIC,
+			) PRIMARY KEY (id)`,
+			expected: []string{"CREATE TABLE table_name (\n  id STRING(255) NOT NULL,\n  sum NUMERIC,\n) PRIMARY KEY(id)"},
+		},
 	}

 	for _, tc := range testCases {
@@ -2,16 +2,16 @@ package sqlcipher

 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"strconv"
 	"strings"
+	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	_ "github.com/mutecomm/go-sqlcipher/v4"
 )

@@ -34,7 +34,7 @@ type Config struct {

 type Sqlite struct {
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	config *Config
 }
@@ -72,11 +72,7 @@ func (m *Sqlite) ensureVersionTable() (err error) {

 	defer func() {
 		if e := m.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -140,9 +136,10 @@ func (m *Sqlite) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()
+
 	tableNames := make([]string, 0)
 	for tables.Next() {
 		var tableName string
@@ -153,6 +150,10 @@ func (m *Sqlite) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
 	if len(tableNames) > 0 {
 		for _, t := range tableNames {
 			query := "DROP TABLE " + t
@@ -172,23 +173,21 @@ func (m *Sqlite) Drop() (err error) {
 }

 func (m *Sqlite) Lock() error {
-	if m.isLocked {
+	if !m.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	m.isLocked = true
 	return nil
 }

 func (m *Sqlite) Unlock() error {
-	if !m.isLocked {
-		return nil
+	if !m.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
 	}
-	m.isLocked = false
 	return nil
 }

 func (m *Sqlite) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -207,7 +206,7 @@ func (m *Sqlite) executeQuery(query string) error {
 	}
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -242,7 +241,7 @@ func (m *Sqlite) SetVersion(version int, dirty bool) error {
 		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, m.config.MigrationsTable)
 		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
@@ -3,8 +3,6 @@ package sqlcipher
 import (
 	"database/sql"
 	"fmt"
-	"io/ioutil"
-	"os"
 	"path/filepath"
 	"testing"

@@ -17,15 +15,7 @@ import (
 )

 func Test(t *testing.T) {
-	dir, err := ioutil.TempDir("", "sqlite3-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))
 	p := &Sqlite{}
 	addr := fmt.Sprintf("sqlite3://%s", filepath.Join(dir, "sqlite3.db"))
@@ -37,15 +27,7 @@ func Test(t *testing.T) {
 }

 func TestMigrate(t *testing.T) {
-	dir, err := ioutil.TempDir("", "sqlite3-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))

 	db, err := sql.Open("sqlite3", filepath.Join(dir, "sqlite3.db"))
@@ -72,15 +54,7 @@ func TestMigrate(t *testing.T) {
 }

 func TestMigrationTable(t *testing.T) {
-	dir, err := ioutil.TempDir("", "sqlite3-driver-test-migration-table")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()

 	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))

@@ -120,15 +94,7 @@ func TestMigrationTable(t *testing.T) {
 }

 func TestNoTxWrap(t *testing.T) {
-	dir, err := ioutil.TempDir("", "sqlite3-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))
 	p := &Sqlite{}
 	addr := fmt.Sprintf("sqlite3://%s?x-no-tx-wrap=true", filepath.Join(dir, "sqlite3.db"))
@@ -142,19 +108,11 @@ func TestNoTxWrap(t *testing.T) {
 }

 func TestNoTxWrapInvalidValue(t *testing.T) {
-	dir, err := ioutil.TempDir("", "sqlite3-driver-test")
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err := os.RemoveAll(dir); err != nil {
-			t.Error(err)
-		}
-	}()
+	dir := t.TempDir()
 	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db"))
 	p := &Sqlite{}
 	addr := fmt.Sprintf("sqlite3://%s?x-no-tx-wrap=yeppers", filepath.Join(dir, "sqlite3.db"))
-	_, err = p.Open(addr)
+	_, err := p.Open(addr)
 	if assert.Error(t, err) {
 		assert.Contains(t, err.Error(), "x-no-tx-wrap")
 		assert.Contains(t, err.Error(), "invalid syntax")
@@ -0,0 +1,17 @@
+# sqlite
+
+`sqlite://path/to/database?query`
+
+Unlike other migrate database drivers, the sqlite driver will automatically wrap each migration in an implicit transaction by default.  Migrations must not contain explicit `BEGIN` or `COMMIT` statements.  This behavior may change in a future major release.  (See below for a workaround.)
+
+The auxiliary query parameters listed below may be supplied to tailor migrate behavior.  All auxiliary query parameters are optional.
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table.  Defaults to `schema_migrations`. |
+| `x-no-tx-wrap` | `NoTxWrap` | Disable implicit transactions when `true`.  Migrations may, and should, contain explicit `BEGIN` and `COMMIT` statements. |
+
+## Notes
+
+* Uses the `modernc.org/sqlite` sqlite db driver (pure Go)
+  * Has [limited `GOOS` and `GOARCH` support](https://pkg.go.dev/modernc.org/sqlite?utm_source=godoc#hdr-Supported_platforms_and_architectures)
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;
@@ -0,0 +1,3 @@
+CREATE TABLE pets (
+  name string
+);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS pets;
@@ -0,0 +1 @@
+ALTER TABLE pets ADD predator bool;
@@ -0,0 +1,264 @@
+package sqlite
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	nurl "net/url"
+	"strconv"
+	"strings"
+	"sync/atomic"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	_ "modernc.org/sqlite"
+)
+
+func init() {
+	database.Register("sqlite", &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
+	NoTxWrap        bool
+}
+
+type Sqlite struct {
+	db       *sql.DB
+	isLocked atomic.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
+}
+
+// ensureVersionTable checks if versions table exists and, if not, creates it.
+// Note that this function locks the database, which deviates from the usual
+// convention of "caller locks" in the Sqlite type.
+func (m *Sqlite) ensureVersionTable() (err error) {
+	if err = m.Lock(); err != nil {
+		return err
+	}
+
+	defer func() {
+		if e := m.Unlock(); e != nil {
+			err = errors.Join(err, e)
+		}
+	}()
+
+	query := fmt.Sprintf(`
+	CREATE TABLE IF NOT EXISTS %s (version uint64,dirty bool);
+  CREATE UNIQUE INDEX IF NOT EXISTS version_unique ON %s (version);
+  `, m.config.MigrationsTable, m.config.MigrationsTable)
+
+	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(), "sqlite://", "", 1)
+	db, err := sql.Open("sqlite", dbfile)
+	if err != nil {
+		return nil, err
+	}
+
+	qv := purl.Query()
+
+	migrationsTable := qv.Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	noTxWrap := false
+	if v := qv.Get("x-no-tx-wrap"); v != "" {
+		noTxWrap, err = strconv.ParseBool(v)
+		if err != nil {
+			return nil, fmt.Errorf("x-no-tx-wrap: %s", err)
+		}
+	}
+
+	mx, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+		NoTxWrap:        noTxWrap,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return mx, nil
+}
+
+func (m *Sqlite) Close() error {
+	return m.db.Close()
+}
+
+func (m *Sqlite) Drop() (err 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 func() {
+		if errClose := tables.Close(); errClose != nil {
+			err = errors.Join(err, errClose)
+		}
+	}()
+
+	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 err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	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)}
+			}
+		}
+		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.CompareAndSwap(false, true) {
+		return database.ErrLocked
+	}
+	return nil
+}
+
+func (m *Sqlite) Unlock() error {
+	if !m.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
+	}
+	return nil
+}
+
+func (m *Sqlite) Run(migration io.Reader) error {
+	migr, err := io.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	query := string(migr[:])
+
+	if m.config.NoTxWrap {
+		return m.executeQueryNoTx(query)
+	}
+	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 {
+		if errRollback := tx.Rollback(); errRollback != nil {
+			err = errors.Join(err, errRollback)
+		}
+		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) executeQueryNoTx(query string) error {
+	if _, err := m.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	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)}
+	}
+
+	// Also re-write the schema version for nil dirty versions to prevent
+	// empty schema version for failed down migration on the first migration
+	// See: https://github.com/golang-migrate/migrate/issues/330
+	if version >= 0 || (version == database.NilVersion && dirty) {
+		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, m.config.MigrationsTable)
+		if _, err := tx.Exec(query, version, dirty); err != nil {
+			if errRollback := tx.Rollback(); errRollback != nil {
+				err = errors.Join(err, errRollback)
+			}
+			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
+}
@@ -0,0 +1,133 @@
+package sqlite
+
+import (
+	"database/sql"
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/golang-migrate/migrate/v4"
+	dt "github.com/golang-migrate/migrate/v4/database/testing"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+	_ "modernc.org/sqlite"
+)
+
+func Test(t *testing.T) {
+	dir := t.TempDir()
+	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite.db"))
+	p := &Sqlite{}
+	addr := fmt.Sprintf("sqlite://%s", filepath.Join(dir, "sqlite.db"))
+	d, err := p.Open(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);"))
+}
+
+func TestMigrate(t *testing.T) {
+	dir := t.TempDir()
+	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite.db"))
+
+	db, err := sql.Open("sqlite", filepath.Join(dir, "sqlite.db"))
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			return
+		}
+	}()
+	driver, err := WithInstance(db, &Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m, err := migrate.NewWithDatabaseInstance(
+		"file://./examples/migrations",
+		"ql", driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dt.TestMigrate(t, m)
+}
+
+func TestMigrationTable(t *testing.T) {
+	dir := t.TempDir()
+
+	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite.db"))
+
+	db, err := sql.Open("sqlite", filepath.Join(dir, "sqlite.db"))
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			return
+		}
+	}()
+
+	config := &Config{
+		MigrationsTable: "my_migration_table",
+	}
+	driver, err := WithInstance(db, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m, err := migrate.NewWithDatabaseInstance(
+		"file://./examples/migrations",
+		"ql", driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log("UP")
+	err = m.Up()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Query(fmt.Sprintf("SELECT * FROM %s", config.MigrationsTable))
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestNoTxWrap(t *testing.T) {
+	dir := t.TempDir()
+	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite.db"))
+	p := &Sqlite{}
+	addr := fmt.Sprintf("sqlite://%s?x-no-tx-wrap=true", filepath.Join(dir, "sqlite.db"))
+	d, err := p.Open(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// An explicit BEGIN statement would ordinarily fail without x-no-tx-wrap.
+	// (Transactions in sqlite may not be nested.)
+	dt.Test(t, d, []byte("BEGIN; CREATE TABLE t (Qty int, Name string); COMMIT;"))
+}
+
+func TestNoTxWrapInvalidValue(t *testing.T) {
+	dir := t.TempDir()
+	t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite.db"))
+	p := &Sqlite{}
+	addr := fmt.Sprintf("sqlite://%s?x-no-tx-wrap=yeppers", filepath.Join(dir, "sqlite.db"))
+	_, err := p.Open(addr)
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "x-no-tx-wrap")
+		assert.Contains(t, err.Error(), "invalid syntax")
+	}
+}
+
+func TestMigrateWithDirectoryNameContainsWhitespaces(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "sqlite.db")
+	t.Logf("DB path : %s\n", dbPath)
+	p := &Sqlite{}
+	addr := fmt.Sprintf("sqlite://file:%s", dbPath)
+	d, err := p.Open(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);"))
+}
@@ -2,12 +2,15 @@

 `sqlite3://path/to/database?query`

-Unlike other migrate database drivers, the sqlite3 driver will automatically wrap each migration in an implicit transaction by default.  Migrations must not contain explicit `BEGIN` or `COMMIT` statements.  This behaviour may change in a future major release.  (See below for a workaround.)
+Unlike other migrate database drivers, the sqlite3 driver will automatically wrap each migration in an implicit transaction by default.  Migrations must not contain explicit `BEGIN` or `COMMIT` statements.  This behavior may change in a future major release.  (See below for a workaround.)

-Refer to [upstream documentation](https://github.com/mattn/go-sqlite3/blob/master/README.md#connection-string) for a complete list of query parameters supported by the sqlite3 database driver.  The auxiliary query parameters listed below may be supplied to tailor migrate behaviour.  All auxiliary query parameters are optional.
+Refer to [upstream documentation](https://github.com/mattn/go-sqlite3/blob/master/README.md#connection-string) for a complete list of query parameters supported by the sqlite3 database driver.  The auxiliary query parameters listed below may be supplied to tailor migrate behavior.  All auxiliary query parameters are optional.

 | URL Query  | WithInstance Config | Description |
 |------------|---------------------|-------------|
 | `x-migrations-table` | `MigrationsTable` | Name of the migrations table.  Defaults to `schema_migrations`. |
 | `x-no-tx-wrap` | `NoTxWrap` | Disable implicit transactions when `true`.  Migrations may, and should, contain explicit `BEGIN` and `COMMIT` statements. |

+## Notes
+
+* Uses the `github.com/mattn/go-sqlite3` sqlite db driver (cgo)
@@ -2,16 +2,16 @@ package sqlite3

 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"strconv"
 	"strings"
+	"sync/atomic"

 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database"
-	"github.com/hashicorp/go-multierror"
 	_ "github.com/mattn/go-sqlite3"
 )

@@ -34,7 +34,7 @@ type Config struct {

 type Sqlite struct {
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool

 	config *Config
 }
@@ -72,11 +72,7 @@ func (m *Sqlite) ensureVersionTable() (err error) {

 	defer func() {
 		if e := m.Unlock(); e != nil {
-			if err == nil {
-				err = e
-			} else {
-				err = multierror.Append(err, e)
-			}
+			err = errors.Join(err, e)
 		}
 	}()

@@ -140,9 +136,10 @@ func (m *Sqlite) Drop() (err error) {
 	}
 	defer func() {
 		if errClose := tables.Close(); errClose != nil {
-			err = multierror.Append(err, errClose)
+			err = errors.Join(err, errClose)
 		}
 	}()
+
 	tableNames := make([]string, 0)
 	for tables.Next() {
 		var tableName string
@@ -153,6 +150,10 @@ func (m *Sqlite) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
 	if len(tableNames) > 0 {
 		for _, t := range tableNames {
 			query := "DROP TABLE " + t
@@ -172,23 +173,21 @@ func (m *Sqlite) Drop() (err error) {
 }

 func (m *Sqlite) Lock() error {
-	if m.isLocked {
+	if !m.isLocked.CompareAndSwap(false, true) {
 		return database.ErrLocked
 	}
-	m.isLocked = true
 	return nil
 }

 func (m *Sqlite) Unlock() error {
-	if !m.isLocked {
-		return nil
+	if !m.isLocked.CompareAndSwap(true, false) {
+		return database.ErrNotLocked
 	}
-	m.isLocked = false
 	return nil
 }

 func (m *Sqlite) Run(migration io.Reader) error {
-	migr, err := ioutil.ReadAll(migration)
+	migr, err := io.ReadAll(migration)
 	if err != nil {
 		return err
 	}
@@ -207,7 +206,7 @@ func (m *Sqlite) executeQuery(query string) error {
 	}
 	if _, err := tx.Exec(query); err != nil {
 		if errRollback := tx.Rollback(); errRollback != nil {
-			err = multierror.Append(err, errRollback)
+			err = errors.Join(err, errRollback)
 		}
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
@@ -242,7 +241,7 @@ func (m *Sqlite) SetVersion(version int, dirty bool) error {
 		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, m.config.MigrationsTable)
 		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
-				err = multierror.Append(err, errRollback)
+				err = errors.Join(err, errRollback)
 			}
 			return &database.Error{OrigErr: err, Query: []byte(query)}
 		}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`ALTER TABLE users DROP COLUMN IF EXISTS city;`
				`@@ -0,0 +1,3 @@`
				`ALTER TABLE users ADD COLUMN city varchar(100);`
				`@@ -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.`