test(endtoend): Use Docker to start database servers

.github/workflows/build.yml

@@ -0,0 +1,19 @@
+name: build
+on:
+  workflow_dispatch:
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, macos-14, windows-2022]
+    name: build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v5
+    - uses: actions/setup-go@v5
+      with:
+        go-version: '1.25.0'
+    - name: install ./...
+      run: go build ./...
+      env:
+        CGO_ENABLED: "0"

.github/workflows/ci.yml

@@ -5,27 +5,25 @@ on:
       - main
   pull_request:
 jobs:
-  test:
+  build:
     strategy:
       matrix:
-        # Disabling windows builds while we fix installing PostgreSQL 16
-        # os: [ubuntu-22.04, macos-14, windows-2022]
-        os: [ubuntu-22.04, macos-15]
-        cgo: ['1', '0']
-        # Workaround no native support for conditional matrix items
-        # https://github.com/orgs/community/discussions/26253#discussioncomment-6745038
-        isMain:
-          - ${{ github.ref == 'refs/heads/main' }}
-        exclude:
-          - isMain: false
-        include:
-        - os: ubuntu-22.04
-          cgo: '1'
-        - os: ubuntu-22.04
-          cgo: '0'
-    name: test ${{ matrix.os }} cgo=${{ matrix.cgo }}
-    runs-on: ${{ matrix.os }}
-
+        goos: [darwin, linux, windows]
+        goarch: [amd64, arm64]
+    name: build ${{ matrix.goos }}/${{ matrix.goarch }}
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v5
+    - uses: actions/setup-go@v5
+      with:
+        go-version: '1.25.0'
+    - run: go build ./...
+      env:
+        CGO_ENABLED: "0"
+        GOOS: ${{ matrix.goos }}
+        GOARCH: ${{ matrix.goarch }}
+  test:
+    runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v5
     - uses: actions/setup-go@v5
@@ -44,37 +42,25 @@ jobs:
     - name: install ./...
       run: go install ./...
       env:
-        CGO_ENABLED: ${{ matrix.cgo }}
+        CGO_ENABLED: "0"
 
     - name: build internal/endtoend
       run: go build ./...
       working-directory: internal/endtoend/testdata
       env:
-        CGO_ENABLED: ${{ matrix.cgo }}
-
-    # Start a PostgreSQL server
-    - uses: sqlc-dev/action-setup-postgres@master
-      with:
-        postgres-version: "16"
-      id: postgres
-
-    # Start a MySQL server
-    - uses: shogo82148/actions-setup-mysql@v1
-      with:
-        mysql-version: "9.0"
+        CGO_ENABLED: "0"
 
     - name: test ./...
       run: gotestsum --junitfile junit.xml -- --tags=examples -timeout 20m ./...
+      if: ${{ matrix.os }} != "windows-2022"
       env:
         CI_SQLC_PROJECT_ID: ${{ secrets.CI_SQLC_PROJECT_ID }}
         CI_SQLC_AUTH_TOKEN: ${{ secrets.CI_SQLC_AUTH_TOKEN }}
         SQLC_AUTH_TOKEN: ${{ secrets.CI_SQLC_AUTH_TOKEN }}
-        MYSQL_SERVER_URI: root:@tcp(localhost:3306)/mysql?multiStatements=true&parseTime=true
-        POSTGRESQL_SERVER_URI: ${{ steps.postgres.outputs.connection-uri }}?sslmode=disable
-        CGO_ENABLED: ${{ matrix.cgo }}
+        CGO_ENABLED: "0"
 
   vuln_check:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     timeout-minutes: 5
 
     steps:

internal/endtoend/endtoend_test.go

@@ -17,7 +17,7 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/cmd"
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/opts"
-	"github.com/sqlc-dev/sqlc/internal/sqltest/local"
+	"github.com/sqlc-dev/sqlc/internal/sqltest/docker"
 )
 
 func lineEndings() cmp.Option {
@@ -112,6 +112,24 @@ func TestReplay(t *testing.T) {
 	// t.Parallel()
 	ctx := context.Background()
 
+	var mysqlURI, postgresURI string
+	if err := docker.Installed(); err == nil {
+		{
+			host, err := docker.StartPostgreSQLServer(ctx)
+			if err != nil {
+				t.Fatalf("starting postgresql failed: %s", err)
+			}
+			postgresURI = host
+		}
+		{
+			host, err := docker.StartMySQLServer(ctx)
+			if err != nil {
+				t.Fatalf("starting mysql failed: %s", err)
+			}
+			mysqlURI = host
+		}
+	}
+
 	contexts := map[string]textContext{
 		"base": {
 			Mutate:  func(t *testing.T, path string) func(*config.Config) { return func(c *config.Config) {} },
@@ -124,13 +142,13 @@ func TestReplay(t *testing.T) {
 						{
 							Name:   "postgres",
 							Engine: config.EnginePostgreSQL,
-							URI:    local.PostgreSQLServer(),
+							URI:    postgresURI,
 						},
 
 						{
 							Name:   "mysql",
 							Engine: config.EngineMySQL,
-							URI:    local.MySQLServer(),
+							URI:    mysqlURI,
 						},
 					}
 					for i := range c.SQL {
@@ -150,13 +168,8 @@ func TestReplay(t *testing.T) {
 				}
 			},
 			Enabled: func() bool {
-				if len(os.Getenv("POSTGRESQL_SERVER_URI")) == 0 {
-					return false
-				}
-				if len(os.Getenv("MYSQL_SERVER_URI")) == 0 {
-					return false
-				}
-				return true
+				err := docker.Installed()
+				return err == nil
 			},
 		},
 	}

internal/sqltest/docker/enabled.go

@@ -0,0 +1,17 @@
+package docker
+
+import (
+	"fmt"
+	"os/exec"
+
+	"golang.org/x/sync/singleflight"
+)
+
+var flight singleflight.Group
+
+func Installed() error {
+	if _, err := exec.LookPath("docker"); err != nil {
+		return fmt.Errorf("docker not found: %w", err)
+	}
+	return nil
+}

internal/sqltest/docker/mysql.go

@@ -0,0 +1,104 @@
+package docker
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+var mysqlHost string
+
+func StartMySQLServer(c context.Context) (string, error) {
+	if err := Installed(); err != nil {
+		return "", err
+	}
+	if mysqlHost != "" {
+		return mysqlHost, nil
+	}
+	value, err, _ := flight.Do("mysql", func() (interface{}, error) {
+		host, err := startMySQLServer(c)
+		if err != nil {
+			return "", err
+		}
+		mysqlHost = host
+		return host, nil
+	})
+	if err != nil {
+		return "", err
+	}
+	data, ok := value.(string)
+	if !ok {
+		return "", fmt.Errorf("returned value was not a string")
+	}
+	return data, nil
+}
+
+func startMySQLServer(c context.Context) (string, error) {
+	{
+		_, err := exec.Command("docker", "pull", "mysql:9").CombinedOutput()
+		if err != nil {
+			return "", fmt.Errorf("docker pull: mysql:9 %w", err)
+		}
+	}
+
+	var exists bool
+	{
+		cmd := exec.Command("docker", "container", "inspect", "sqlc_sqltest_docker_mysql")
+		// This means we've already started the container
+		exists = cmd.Run() == nil
+	}
+
+	if !exists {
+		cmd := exec.Command("docker", "run",
+			"--name", "sqlc_sqltest_docker_mysql",
+			"-e", "MYSQL_ROOT_PASSWORD=mysecretpassword",
+			"-e", "MYSQL_DATABASE=dinotest",
+			"-p", "3306:3306",
+			"-d",
+			"mysql:9",
+		)
+
+		output, err := cmd.CombinedOutput()
+		fmt.Println(string(output))
+
+		msg := `Conflict. The container name "/sqlc_sqltest_docker_mysql" is already in use by container`
+		if !strings.Contains(string(output), msg) && err != nil {
+			return "", err
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(c, 10*time.Second)
+	defer cancel()
+
+	// Create a ticker that fires every 10ms
+	ticker := time.NewTicker(10 * time.Millisecond)
+	defer ticker.Stop()
+
+	uri := "root:mysecretpassword@/dinotest?multiStatements=true&parseTime=true"
+
+	db, err := sql.Open("mysql", uri)
+	if err != nil {
+		return "", fmt.Errorf("sql.Open: %w", err)
+	}
+
+	defer db.Close()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return "", fmt.Errorf("timeout reached: %w", ctx.Err())
+
+		case <-ticker.C:
+			// Run your function here
+			if err := db.PingContext(ctx); err != nil {
+				continue
+			}
+			return uri, nil
+		}
+	}
+}