Apply fast PostgreSQL settings to sqlc-test-setup and native test helper

Both the sqlc-test-setup CLI tool and the native test helper now detect
postgresql.conf at runtime and append the same speed-optimized settings
used in Dockerfile.postgres: fsync=off, synchronous_commit=off,
full_page_writes=off, wal_level=minimal, etc.

Settings are applied idempotently (a marker comment prevents duplicate
entries) and trigger a full restart since wal_level and max_connections
require it. This brings CI and non-Docker test environments to parity
with the Docker fast-startup image.

https://claude.ai/code/session_018Godbm3DFdWJf5jc7NU8Uq

Author: claude

cmd/sqlc-test-setup/main.go

@@ -266,6 +266,10 @@ func startPostgreSQL() error {
 		return fmt.Errorf("configuring pg_hba.conf: %w", err)
 	}
 
+	if err := applyFastSettings(); err != nil {
+		return fmt.Errorf("applying fast postgresql settings: %w", err)
+	}
+
 	log.Println("reloading postgresql configuration")
 	if err := run("sudo", "service", "postgresql", "reload"); err != nil {
 		return fmt.Errorf("reloading postgresql: %w", err)
@@ -313,6 +317,78 @@ func ensurePgHBAEntry(hbaPath string) error {
 	return run("bash", "-c", cmd)
 }
 
+// pgFastSettings are PostgreSQL settings that sacrifice durability for speed.
+// They are unsafe for production but ideal for test databases.
+var pgFastSettings = map[string]string{
+	"fsync":               "off",
+	"synchronous_commit":  "off",
+	"full_page_writes":    "off",
+	"max_connections":     "200",
+	"wal_level":           "minimal",
+	"max_wal_senders":     "0",
+	"max_wal_size":        "256MB",
+	"checkpoint_timeout":  "30min",
+	"log_min_messages":    "FATAL",
+	"log_statement":       "none",
+}
+
+// detectPgConfigPath returns the path to postgresql.conf by querying the running server.
+func detectPgConfigPath() (string, error) {
+	out, err := runOutput("bash", "-c", "sudo -u postgres psql -t -c 'SHOW config_file;'")
+	if err != nil {
+		return "", fmt.Errorf("querying config_file: %w (output: %s)", err, out)
+	}
+	path := strings.TrimSpace(out)
+	if path == "" {
+		return "", fmt.Errorf("postgresql.conf path is empty")
+	}
+	log.Printf("found postgresql.conf at %s", path)
+	return path, nil
+}
+
+// applyFastSettings detects postgresql.conf and appends speed-optimized settings
+// for test workloads. Settings that are already present are skipped. A restart
+// is needed for some settings (e.g. wal_level, max_connections) to take effect.
+func applyFastSettings() error {
+	confPath, err := detectPgConfigPath()
+	if err != nil {
+		return err
+	}
+
+	out, err := runOutput("sudo", "cat", confPath)
+	if err != nil {
+		return fmt.Errorf("reading postgresql.conf: %w", err)
+	}
+
+	// Check if we've already applied settings by looking for our marker comment.
+	if strings.Contains(out, "# sqlc test optimizations") {
+		log.Println("fast postgresql settings already applied, skipping")
+		return nil
+	}
+
+	log.Println("applying fast postgresql settings for test workloads")
+
+	var block strings.Builder
+	block.WriteString("\n# sqlc test optimizations\n")
+	for key, value := range pgFastSettings {
+		block.WriteString(fmt.Sprintf("%s = %s\n", key, value))
+	}
+
+	cmd := fmt.Sprintf("echo '%s' | sudo tee -a %s", block.String(), confPath)
+	if err := run("bash", "-c", cmd); err != nil {
+		return fmt.Errorf("appending settings to postgresql.conf: %w", err)
+	}
+
+	// Some settings (wal_level, max_connections, shared_buffers) require a
+	// full restart rather than just a reload.
+	log.Println("restarting postgresql for settings that require a restart")
+	if err := run("sudo", "service", "postgresql", "restart"); err != nil {
+		return fmt.Errorf("restarting postgresql: %w", err)
+	}
+
+	return nil
+}
+
 func startMySQL() error {
 	log.Println("--- Starting MySQL ---")
 

internal/sqltest/native/postgres.go

@@ -114,6 +114,21 @@ func startPostgresService() error {
 	return nil
 }
 
+// pgFastSettings are PostgreSQL settings that sacrifice durability for speed.
+// They are unsafe for production but ideal for test databases.
+var pgFastSettings = [][2]string{
+	{"fsync", "off"},
+	{"synchronous_commit", "off"},
+	{"full_page_writes", "off"},
+	{"max_connections", "200"},
+	{"wal_level", "minimal"},
+	{"max_wal_senders", "0"},
+	{"max_wal_size", "256MB"},
+	{"checkpoint_timeout", "30min"},
+	{"log_min_messages", "FATAL"},
+	{"log_statement", "none"},
+}
+
 func configurePostgres() error {
 	// Set password for postgres user using sudo -u postgres
 	cmd := exec.Command("sudo", "-u", "postgres", "psql", "-c", "ALTER USER postgres PASSWORD 'postgres';")
@@ -162,9 +177,86 @@ func configurePostgres() error {
 		}
 	}
 
+	// Apply speed-optimized settings for test workloads
+	if err := applyFastSettings(); err != nil {
+		slog.Warn("native/postgres", "fast-settings-error", err)
+	}
+
 	return nil
 }
 
+// applyFastSettings appends speed-optimized settings to postgresql.conf for
+// test workloads. Settings that sacrifice durability for speed (fsync=off, etc.)
+// are applied once and require a restart to take effect.
+func applyFastSettings() error {
+	output, err := exec.Command("sudo", "-u", "postgres", "psql", "-t", "-c", "SHOW config_file;").CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("could not find config_file: %w", err)
+	}
+
+	confFile := strings.TrimSpace(string(output))
+	if confFile == "" {
+		return fmt.Errorf("empty config_file path")
+	}
+
+	catOutput, err := exec.Command("sudo", "cat", confFile).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("could not read %s: %w", confFile, err)
+	}
+
+	// Check if we've already applied settings.
+	if strings.Contains(string(catOutput), "# sqlc test optimizations") {
+		slog.Debug("native/postgres", "fast-settings", "already applied")
+		return nil
+	}
+
+	slog.Info("native/postgres", "status", "applying fast settings to postgresql.conf")
+
+	var block strings.Builder
+	block.WriteString("\n# sqlc test optimizations\n")
+	for _, kv := range pgFastSettings {
+		fmt.Fprintf(&block, "%s = %s\n", kv[0], kv[1])
+	}
+
+	cmd := exec.Command("sudo", "bash", "-c",
+		fmt.Sprintf("echo '%s' | sudo tee -a %s", block.String(), confFile))
+	if out, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("appending settings to postgresql.conf: %w\n%s", err, out)
+	}
+
+	// Some settings (wal_level, max_connections) require a full restart.
+	slog.Info("native/postgres", "status", "restarting postgresql for fast settings")
+	if err := restartPostgres(); err != nil {
+		return fmt.Errorf("restart for fast settings: %w", err)
+	}
+
+	return nil
+}
+
+func restartPostgres() error {
+	// Try systemctl restart
+	cmd := exec.Command("sudo", "systemctl", "restart", "postgresql")
+	if err := cmd.Run(); err == nil {
+		return nil
+	}
+
+	// Try service restart
+	cmd = exec.Command("sudo", "service", "postgresql", "restart")
+	if err := cmd.Run(); err == nil {
+		return nil
+	}
+
+	// Try pg_ctlcluster restart
+	output, _ := exec.Command("ls", "/etc/postgresql/").CombinedOutput()
+	versions := strings.Fields(string(output))
+	if len(versions) > 0 {
+		cmd = exec.Command("sudo", "pg_ctlcluster", versions[0], "main", "restart")
+		return cmd.Run()
+	}
+
+	return fmt.Errorf("could not restart PostgreSQL")
+}
+
 func reloadPostgres() error {
 	// Try systemctl reload
 	cmd := exec.Command("sudo", "systemctl", "reload", "postgresql")