clickhouse: wire end-to-end sqlc generate onto the core

Add the EngineClickHouse engine and a dedicated compile path so
`sqlc generate` produces Go for ClickHouse entirely through the xqlc
core, bypassing the legacy compiler analyze step and the in-memory
sql/catalog:

- config: add the "clickhouse" engine constant.
- compiler: NewCompiler builds a core.Catalog seeded with the ClickHouse
  dialect; parseCatalog applies schema DDL to it; a new parseQueryCore
  resolves each query's columns and parameters via core/analyzer and
  assembles *compiler.Query, reusing only the shared query-metadata
  parsing. The legacy analyzeQuery/inferQuery/outputColumns path and the
  analyzer.Analyzer seam are never entered.
- codegen: project the core catalog into plugin.Catalog for model/enum
  generation, and add a ClickHouse -> Go type map (Nullable(T) -> *T,
  the integer ladder, Float32/64, String, DateTime -> time.Time, ...).
- clickhouse parser: compute statement byte-spans with a running offset
  and a semicolon scan (doubleclick reports statement starts but not
  ends), so leading "-- name:" annotations fall inside each statement.

An endtoend case (clickhouse_select) exercises the full pipeline and its
golden Go output is committed. Updating parse_basic/clickhouse's golden
reflects the corrected statement spans and now-detected query name/cmd.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XTGxNHW6v1S1YyC9FDSgrK

Author: kyleconroy

internal/cmd/shim.go

@@ -4,6 +4,7 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/compiler"
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/config/convert"
+	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/info"
 	"github.com/sqlc-dev/sqlc/internal/plugin"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
@@ -224,10 +225,90 @@ func pluginQueryParam(p compiler.Parameter) *plugin.Parameter {
 }
 
 func codeGenRequest(r *compiler.Result, settings config.CombinedSettings) *plugin.GenerateRequest {
+	// Engines on the xqlc core (ClickHouse) project the codegen catalog
+	// from the core catalog rather than the in-memory sql/catalog, which is
+	// nil on that path.
+	var cat *plugin.Catalog
+	if r.CoreCatalog != nil {
+		cat = pluginCatalogFromCore(r.CoreCatalog)
+	} else {
+		cat = pluginCatalog(r.Catalog)
+	}
 	return &plugin.GenerateRequest{
 		Settings:    pluginSettings(r, settings),
-		Catalog:     pluginCatalog(r.Catalog),
+		Catalog:     cat,
 		Queries:     pluginQueries(r),
 		SqlcVersion: info.Version,
 	}
 }
+
+// pluginCatalogFromCore projects a core.Catalog (the xqlc SQLite-backed
+// catalog) into the plugin.Catalog that codegen consumes to emit models
+// and enums. It reads the namespace / class / attribute / type tables
+// directly. Projection is best-effort: an unexpected query error against
+// the in-memory catalog yields a partial catalog rather than aborting
+// generation.
+func pluginCatalogFromCore(cc *core.Catalog) *plugin.Catalog {
+	db := cc.DB()
+	var schemas []*plugin.Schema
+
+	type row struct {
+		oid  int64
+		name string
+	}
+	readRows := func(query string, args ...any) []row {
+		rows, err := db.Query(query, args...)
+		if err != nil {
+			return nil
+		}
+		defer rows.Close()
+		var out []row
+		for rows.Next() {
+			var r row
+			if err := rows.Scan(&r.oid, &r.name); err != nil {
+				return out
+			}
+			out = append(out, r)
+		}
+		return out
+	}
+
+	for _, ns := range readRows(`SELECT oid, name FROM sql_namespace ORDER BY oid`) {
+		var tables []*plugin.Table
+		for _, cl := range readRows(
+			`SELECT oid, name FROM sql_class WHERE namespace_oid = ? AND kind = 'r' ORDER BY oid`, ns.oid,
+		) {
+			rel := &plugin.Identifier{Schema: ns.name, Name: cl.name}
+			var columns []*plugin.Column
+			crows, err := db.Query(
+				`SELECT a.name, t.name, a.not_null
+				 FROM sql_attribute a JOIN sql_type t ON t.oid = a.type_oid
+				 WHERE a.class_oid = ? ORDER BY a.num`, cl.oid,
+			)
+			if err != nil {
+				continue
+			}
+			for crows.Next() {
+				var name, typeName string
+				var notNull int
+				if err := crows.Scan(&name, &typeName, &notNull); err != nil {
+					break
+				}
+				columns = append(columns, &plugin.Column{
+					Name:    name,
+					Type:    &plugin.Identifier{Name: typeName},
+					NotNull: notNull != 0,
+					Table:   rel,
+				})
+			}
+			crows.Close()
+			tables = append(tables, &plugin.Table{Rel: rel, Columns: columns})
+		}
+		schemas = append(schemas, &plugin.Schema{Name: ns.name, Tables: tables})
+	}
+
+	return &plugin.Catalog{
+		DefaultSchema: "public",
+		Schemas:       schemas,
+	}
+}

internal/codegen/golang/clickhouse_type.go

@@ -0,0 +1,68 @@
+package golang
+
+import (
+	"strings"
+
+	"github.com/sqlc-dev/sqlc/internal/codegen/golang/opts"
+	"github.com/sqlc-dev/sqlc/internal/codegen/sdk"
+	"github.com/sqlc-dev/sqlc/internal/plugin"
+)
+
+// clickhouseType maps a ClickHouse column type to a Go type. Type names
+// arrive lower-cased from the core catalog (e.g. "uint64", "string",
+// "datetime"). Nullable columns (NotNull == false) map to a pointer, which
+// is how the clickhouse-go driver represents Nullable(T).
+func clickhouseType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Column) string {
+	dt := strings.ToLower(sdk.DataType(col.Type))
+	notNull := col.NotNull
+
+	switch dt {
+	case "uint8":
+		return nullable(notNull, "uint8")
+	case "uint16":
+		return nullable(notNull, "uint16")
+	case "uint32":
+		return nullable(notNull, "uint32")
+	case "uint64":
+		return nullable(notNull, "uint64")
+	case "int8":
+		return nullable(notNull, "int8")
+	case "int16":
+		return nullable(notNull, "int16")
+	case "int32":
+		return nullable(notNull, "int32")
+	case "int64":
+		return nullable(notNull, "int64")
+	case "uint128", "uint256", "int128", "int256":
+		// Big integers are represented as *big.Int by clickhouse-go.
+		return "*big.Int"
+	case "float32", "bfloat16":
+		return nullable(notNull, "float32")
+	case "float64":
+		return nullable(notNull, "float64")
+	case "bool":
+		return nullable(notNull, "bool")
+	case "string", "fixedstring":
+		return nullable(notNull, "string")
+	case "date", "date32", "datetime", "datetime64":
+		return nullable(notNull, "time.Time")
+
+	// The following resolve to string for now; richer mappings
+	// (decimal.Decimal, uuid.UUID, netip.Addr, json.RawMessage) require
+	// wiring their imports into the Go importer and are a follow-up.
+	case "decimal", "decimal32", "decimal64", "decimal128", "decimal256",
+		"uuid", "ipv4", "ipv6", "json", "enum8", "enum16":
+		return nullable(notNull, "string")
+
+	default:
+		return "interface{}"
+	}
+}
+
+// nullable wraps a base Go type in a pointer when the column is nullable.
+func nullable(notNull bool, base string) string {
+	if notNull {
+		return base
+	}
+	return "*" + base
+}

internal/codegen/golang/go_type.go

@@ -86,6 +86,8 @@ func goInnerType(req *plugin.GenerateRequest, options *opts.Options, col *plugin
 		return postgresType(req, options, col)
 	case "sqlite":
 		return sqliteType(req, options, col)
+	case "clickhouse":
+		return clickhouseType(req, options, col)
 	default:
 		return "interface{}"
 	}

internal/compiler/compile.go

@@ -9,6 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/sqlc-dev/sqlc/internal/engine/clickhouse"
 	"github.com/sqlc-dev/sqlc/internal/migrations"
 	"github.com/sqlc-dev/sqlc/internal/multierr"
 	"github.com/sqlc-dev/sqlc/internal/opts"
@@ -55,6 +56,18 @@ func (c *Compiler) parseCatalog(schemas []string) error {
 			continue
 		}
 
+		// ClickHouse populates the core catalog instead of the in-memory
+		// sql/catalog.
+		if c.coreCatalog != nil {
+			for i := range stmts {
+				if err := clickhouse.Apply(c.coreCatalog, stmts[i].Raw); err != nil {
+					merr.Add(filename, contents, stmts[i].Pos(), err)
+					continue
+				}
+			}
+			continue
+		}
+
 		for i := range stmts {
 			if err := c.catalog.Update(stmts[i], c); err != nil {
 				merr.Add(filename, contents, stmts[i].Pos(), err)
@@ -135,7 +148,8 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 	}
 
 	return &Result{
-		Catalog: c.catalog,
-		Queries: q,
+		Catalog:     c.catalog,
+		CoreCatalog: c.coreCatalog,
+		Queries:     q,
 	}, nil
 }

internal/compiler/engine.go

@@ -6,7 +6,9 @@ import (
 
 	"github.com/sqlc-dev/sqlc/internal/analyzer"
 	"github.com/sqlc-dev/sqlc/internal/config"
+	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/dbmanager"
+	"github.com/sqlc-dev/sqlc/internal/engine/clickhouse"
 	"github.com/sqlc-dev/sqlc/internal/engine/dolphin"
 	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
 	pganalyze "github.com/sqlc-dev/sqlc/internal/engine/postgresql/analyzer"
@@ -27,6 +29,11 @@ type Compiler struct {
 	client   dbmanager.Client
 	selector selector
 
+	// coreCatalog is the xqlc-derived catalog used by engines whose
+	// analysis runs on the core analyzer (currently ClickHouse) instead of
+	// the legacy compiler analyze step. It is nil for other engines.
+	coreCatalog *core.Catalog
+
 	schema []string
 
 	// databaseOnlyMode indicates that the compiler should use database-only analysis
@@ -111,6 +118,17 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts
 				)
 			}
 		}
+	case config.EngineClickHouse:
+		// ClickHouse runs on the xqlc analysis core: its schema and queries
+		// are resolved against a core.Catalog by the core analyzer, not the
+		// legacy compiler analyze step or the in-memory sql/catalog.
+		c.parser = clickhouse.NewParser()
+		c.selector = newDefaultSelector()
+		cat, err := core.New(clickhouse.Dialect())
+		if err != nil {
+			return nil, fmt.Errorf("clickhouse: init catalog: %w", err)
+		}
+		c.coreCatalog = cat
 	default:
 		return nil, fmt.Errorf("unknown engine: %s", conf.Engine)
 	}
@@ -145,4 +163,7 @@ func (c *Compiler) Close(ctx context.Context) {
 	if c.client != nil {
 		c.client.Close(ctx)
 	}
+	if c.coreCatalog != nil {
+		c.coreCatalog.Close()
+	}
 }

internal/compiler/parse.go

@@ -19,6 +19,12 @@ import (
 var debugDumpAST = sqlcdebug.New("dumpast")
 
 func (c *Compiler) parseQuery(stmt ast.Node, src string, o opts.Parser) (*Query, error) {
+	// ClickHouse resolves types through the core analyzer, entirely
+	// bypassing the legacy analyze step below.
+	if c.coreCatalog != nil {
+		return c.parseQueryCore(stmt, src)
+	}
+
 	ctx := context.Background()
 
 	if debugDumpAST.Value() == "1" {