Add fast-startup PostgreSQL Dockerfile for testing

Pre-initialize the database at Docker build time so container startup
only needs to launch the postgres process — no initdb, no entrypoint
scripts. Combined with aggressive durability-off settings (fsync=off,
synchronous_commit=off, wal_level=minimal), this cuts container startup
from ~1-2s to near-instant.

Key changes:
- Dockerfile.postgres: pre-initialized PG 18 image with test-tuned config
- docker-compose.yml: build from Dockerfile.postgres instead of pulling
- internal/sqltest/docker/postgres.go: auto-build the fast image on first
  test run, pipe Dockerfile via stdin to avoid sending build context

https://claude.ai/code/session_018Godbm3DFdWJf5jc7NU8Uq

Author: claude

Dockerfile.postgres

@@ -0,0 +1,71 @@
+# Fast-startup PostgreSQL for sqlc testing
+#
+# This image pre-initializes the database at build time so that container
+# startup only needs to launch the postgres process — no initdb, no
+# entrypoint scripts, no first-run setup.
+#
+# Build:
+#   docker build -f Dockerfile.postgres -t sqlc-postgres .
+#
+# Run:
+#   docker run -d -p 5432:5432 sqlc-postgres
+#
+# For fastest I/O, mount the data directory on tmpfs:
+#   docker run -d -p 5432:5432 --tmpfs /var/lib/postgresql/data:rw,noexec,nosuid,size=256m sqlc-postgres
+#
+# Connection URI:
+#   postgres://postgres:mysecretpassword@localhost:5432/postgres?sslmode=disable
+
+ARG PG_VERSION=18
+FROM postgres:${PG_VERSION}
+
+ENV POSTGRES_USER=postgres \
+    POSTGRES_PASSWORD=mysecretpassword \
+    POSTGRES_DB=postgres \
+    PGDATA=/var/lib/postgresql/data
+
+# Pre-initialize the database at build time and apply speed-optimized
+# configuration. This eliminates the ~1-2s initdb cost on every container start.
+RUN set -eux; \
+    mkdir -p "$PGDATA"; \
+    chown postgres:postgres "$PGDATA"; \
+    echo "$POSTGRES_PASSWORD" > /tmp/pwfile; \
+    gosu postgres initdb \
+        --username="$POSTGRES_USER" \
+        --pwfile=/tmp/pwfile \
+        -D "$PGDATA"; \
+    rm /tmp/pwfile; \
+    \
+    # --- Performance settings (unsafe for production, ideal for tests) --- \
+    { \
+        echo ""; \
+        echo "# === sqlc test optimizations ==="; \
+        echo "listen_addresses = '*'"; \
+        echo "fsync = off"; \
+        echo "synchronous_commit = off"; \
+        echo "full_page_writes = off"; \
+        echo "max_connections = 200"; \
+        echo "shared_buffers = 128MB"; \
+        echo "wal_level = minimal"; \
+        echo "max_wal_senders = 0"; \
+        echo "max_wal_size = 256MB"; \
+        echo "checkpoint_timeout = 30min"; \
+        echo "log_min_messages = FATAL"; \
+        echo "log_statement = none"; \
+    } >> "$PGDATA/postgresql.conf"; \
+    \
+    # --- Allow password auth from any host --- \
+    echo "host all all 0.0.0.0/0 scram-sha-256" >> "$PGDATA/pg_hba.conf"; \
+    echo "host all all ::/0 scram-sha-256" >> "$PGDATA/pg_hba.conf"
+
+EXPOSE 5432
+
+# SIGINT = "fast shutdown": disconnects clients and exits cleanly without
+# requiring crash recovery on the next start. Much faster than the default
+# SIGTERM ("smart shutdown") which waits for all clients to disconnect.
+STOPSIGNAL SIGINT
+
+USER postgres
+
+# Start postgres directly, bypassing docker-entrypoint.sh entirely.
+CMD ["postgres"]

docker-compose.yml

@@ -11,11 +11,9 @@ services:
       MYSQL_ROOT_HOST: '%'
 
   postgresql:
-    image: "postgres:16"
+    build:
+      context: .
+      dockerfile: Dockerfile.postgres
     ports:
       - "5432:5432"
     restart: always
-    environment:
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: mysecretpassword
-      POSTGRES_USER: postgres

internal/sqltest/docker/postgres.go

@@ -1,10 +1,13 @@
 package docker
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"log/slog"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"time"
 
@@ -13,6 +16,8 @@ import (
 
 var postgresHost string
 
+const postgresImageName = "sqlc-postgres"
+
 func StartPostgreSQLServer(c context.Context) (string, error) {
 	if err := Installed(); err != nil {
 		return "", err
@@ -38,11 +43,57 @@ func StartPostgreSQLServer(c context.Context) (string, error) {
 	return data, nil
 }
 
+// findRepoRoot walks up from the current directory to find the directory
+// containing go.mod, which is the repository root.
+func findRepoRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir, nil
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", fmt.Errorf("could not find repo root (go.mod)")
+		}
+		dir = parent
+	}
+}
+
+// buildPostgresImage builds the fast-startup PostgreSQL image from
+// Dockerfile.postgres. The Dockerfile requires no build context, so we
+// pipe it to `docker build -` to avoid sending the repo tree to the daemon.
+func buildPostgresImage() error {
+	root, err := findRepoRoot()
+	if err != nil {
+		return err
+	}
+	content, err := os.ReadFile(filepath.Join(root, "Dockerfile.postgres"))
+	if err != nil {
+		return fmt.Errorf("read Dockerfile.postgres: %w", err)
+	}
+	cmd := exec.Command("docker", "build", "-t", postgresImageName, "-")
+	cmd.Stdin = bytes.NewReader(content)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("docker build sqlc-postgres: %w\n%s", err, output)
+	}
+	return nil
+}
+
+// postgresImageExists checks whether the sqlc-postgres image is already built.
+func postgresImageExists() bool {
+	cmd := exec.Command("docker", "image", "inspect", postgresImageName)
+	return cmd.Run() == nil
+}
+
 func startPostgreSQLServer(c context.Context) (string, error) {
-	{
-		_, err := exec.Command("docker", "pull", "postgres:16").CombinedOutput()
-		if err != nil {
-			return "", fmt.Errorf("docker pull: postgres:16 %w", err)
+	// Build the fast-startup image if it doesn't already exist.
+	if !postgresImageExists() {
+		if err := buildPostgresImage(); err != nil {
+			return "", err
 		}
 	}
 
@@ -56,14 +107,13 @@ func startPostgreSQLServer(c context.Context) (string, error) {
 	}
 
 	if !exists {
+		// The sqlc-postgres image is pre-initialized and pre-configured,
+		// so no environment variables or extra flags are needed.
 		cmd := exec.Command("docker", "run",
 			"--name", "sqlc_sqltest_docker_postgres",
-			"-e", "POSTGRES_PASSWORD=mysecretpassword",
-			"-e", "POSTGRES_USER=postgres",
 			"-p", "5432:5432",
 			"-d",
-			"postgres:16",
-			"-c", "max_connections=200",
+			postgresImageName,
 		)
 
 		output, err := cmd.CombinedOutput()
@@ -88,7 +138,6 @@ func startPostgreSQLServer(c context.Context) (string, error) {
 			return "", fmt.Errorf("timeout reached: %w", ctx.Err())
 
 		case <-ticker.C:
-			// Run your function here
 			conn, err := pgx.Connect(ctx, uri)
 			if err != nil {
 				slog.Debug("sqltest", "connect", err)