Add ClickHouse test database adapters

Docker and local connection adapters for integration testing.
Enables end-to-end testing with real ClickHouse instances.

Author: mgilbir

internal/sqltest/docker/clickhouse.go

@@ -0,0 +1,109 @@
+package docker
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"os/exec"
+	"strings"
+	"time"
+
+	_ "github.com/ClickHouse/clickhouse-go/v2"
+)
+
+var clickhouseHost string
+
+func StartClickHouseServer(c context.Context) (string, error) {
+	if err := Installed(); err != nil {
+		return "", err
+	}
+	if clickhouseHost != "" {
+		return clickhouseHost, nil
+	}
+	value, err, _ := flight.Do("clickhouse", func() (interface{}, error) {
+		host, err := startClickHouseServer(c)
+		if err != nil {
+			return "", err
+		}
+		clickhouseHost = host
+		return host, err
+	})
+	if err != nil {
+		return "", err
+	}
+	data, ok := value.(string)
+	if !ok {
+		return "", fmt.Errorf("returned value was not a string")
+	}
+	return data, nil
+}
+
+func startClickHouseServer(c context.Context) (string, error) {
+	{
+		_, err := exec.Command("docker", "pull", "clickhouse:lts").CombinedOutput()
+		if err != nil {
+			return "", fmt.Errorf("docker pull: clickhouse:lts %w", err)
+		}
+	}
+
+	var exists bool
+	{
+		cmd := exec.Command("docker", "container", "inspect", "sqlc_sqltest_docker_clickhouse")
+		// This means we've already started the container
+		exists = cmd.Run() == nil
+	}
+
+	if !exists {
+		cmd := exec.Command("docker", "run",
+			"--name", "sqlc_sqltest_docker_clickhouse",
+			"-p", "9000:9000",
+			"-p", "8123:8123",
+			"-e", "CLICKHOUSE_DB=default",
+			"-e", "CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT=1",
+			"-d",
+			"clickhouse:lts",
+		)
+
+		output, err := cmd.CombinedOutput()
+		fmt.Println(string(output))
+
+		msg := `Conflict. The container name "/sqlc_sqltest_docker_clickhouse" 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()
+
+	// ClickHouse DSN format: clickhouse://host:port
+	dsn := "clickhouse://localhost:9000/default"
+
+	for {
+		select {
+		case <-ctx.Done():
+			return "", fmt.Errorf("timeout reached: %w", ctx.Err())
+
+		case <-ticker.C:
+			db, err := sql.Open("clickhouse", dsn)
+			if err != nil {
+				slog.Debug("sqltest", "open", err)
+				continue
+			}
+
+			if err := db.PingContext(ctx); err != nil {
+				slog.Debug("sqltest", "ping", err)
+				db.Close()
+				continue
+			}
+
+			db.Close()
+			return dsn, nil
+		}
+	}
+}

internal/sqltest/local/clickhouse.go

@@ -0,0 +1,99 @@
+package local
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"hash/fnv"
+	"os"
+	"strings"
+	"testing"
+
+	migrate "github.com/sqlc-dev/sqlc/internal/migrations"
+	"github.com/sqlc-dev/sqlc/internal/sql/sqlpath"
+	"github.com/sqlc-dev/sqlc/internal/sqltest/docker"
+
+	_ "github.com/ClickHouse/clickhouse-go/v2"
+)
+
+func ClickHouse(t *testing.T, migrations []string) string {
+	ctx := context.Background()
+	t.Helper()
+
+	dburi := os.Getenv("CLICKHOUSE_SERVER_URI")
+	if dburi == "" {
+		if ierr := docker.Installed(); ierr == nil {
+			u, err := docker.StartClickHouseServer(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			dburi = u
+		} else {
+			t.Skip("CLICKHOUSE_SERVER_URI is empty")
+		}
+	}
+
+	// Open connection to ClickHouse
+	db, err := sql.Open("clickhouse", dburi)
+	if err != nil {
+		t.Fatalf("ClickHouse connection failed: %s", err)
+	}
+	defer db.Close()
+
+	var seed []string
+	files, err := sqlpath.Glob(migrations)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h := fnv.New64()
+	for _, f := range files {
+		blob, err := os.ReadFile(f)
+		if err != nil {
+			t.Fatal(err)
+		}
+		h.Write(blob)
+		seed = append(seed, migrate.RemoveRollbackStatements(string(blob)))
+	}
+
+	// Create unique database name
+	name := fmt.Sprintf("sqlc_test_%x", h.Sum(nil))
+
+	// Drop database if it exists (ClickHouse style)
+	dropQuery := fmt.Sprintf(`DROP DATABASE IF EXISTS %s`, name)
+	if _, err := db.ExecContext(ctx, dropQuery); err != nil {
+		t.Logf("could not drop database (may not exist): %s", err)
+	}
+
+	// Create new database
+	createQuery := fmt.Sprintf(`CREATE DATABASE IF NOT EXISTS %s`, name)
+	if _, err := db.ExecContext(ctx, createQuery); err != nil {
+		t.Fatalf("failed to create database: %s", err)
+	}
+
+	// Execute migration scripts
+	dbWithDatabase := fmt.Sprintf("%s?database=%s", dburi, name)
+	dbConn, err := sql.Open("clickhouse", dbWithDatabase)
+	if err != nil {
+		t.Fatalf("ClickHouse connection to new database failed: %s", err)
+	}
+	defer dbConn.Close()
+
+	for _, q := range seed {
+		if len(strings.TrimSpace(q)) == 0 {
+			continue
+		}
+		if _, err := dbConn.ExecContext(ctx, q); err != nil {
+			t.Fatalf("migration failed: %s: %s", q, err)
+		}
+	}
+
+	// Register cleanup
+	t.Cleanup(func() {
+		if _, err := db.ExecContext(ctx, dropQuery); err != nil {
+			t.Logf("failed cleaning up database: %s", err)
+		}
+	})
+
+	return dbWithDatabase
+}