clickhouse: analyze queries through the core catalog + analyzer

Wire ClickHouse onto the merged core: a dialect seed registering the
built-in ClickHouse types, and a DDL handler that populates the core
catalog from CREATE TABLE using sqlc's existing ClickHouse parser. A
smoke test proves the full vertical path — ClickHouse SQL -> sqlc's
ClickHouse parser -> internal/sql/ast -> core catalog + analyzer ->
PrepareResult — resolving column names, types, nullability, source
bindings, and star expansion, with none of the legacy compiler analyze
step involved.

Also fix the ClickHouse converter to render nested type parameters
(the inner type of Nullable(T)/Array(T), Decimal precision, etc.) into
TypeName.Name instead of dropping them as TODO nodes, so wrapped types
resolve to their effective scalar type.

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

Author: kyleconroy

internal/engine/clickhouse/analyze_test.go

@@ -0,0 +1,100 @@
+package clickhouse_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/sqlc-dev/sqlc/internal/core"
+	"github.com/sqlc-dev/sqlc/internal/core/analyzer"
+	"github.com/sqlc-dev/sqlc/internal/engine/clickhouse"
+)
+
+// analyzeOne seeds a ClickHouse-dialect catalog, applies ddl, then runs
+// the dialect-neutral core analyzer over the trailing query. It proves
+// the full ClickHouse vertical path: ClickHouse SQL -> sqlc's ClickHouse
+// parser -> internal/sql/ast -> core catalog + analyzer -> PrepareResult,
+// with no legacy compiler analyze step involved.
+func analyzeOne(t *testing.T, ddl, query string) core.PrepareResult {
+	t.Helper()
+	cat, err := core.New(clickhouse.Dialect())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { cat.Close() })
+
+	if err := clickhouse.LoadSchema(cat, ddl); err != nil {
+		t.Fatalf("load schema: %v", err)
+	}
+
+	stmts, err := clickhouse.NewParser().Parse(strings.NewReader(query))
+	if err != nil {
+		t.Fatalf("parse query: %v", err)
+	}
+	if len(stmts) != 1 {
+		t.Fatalf("expected 1 stmt, got %d", len(stmts))
+	}
+	res, err := analyzer.Prepare(cat, stmts[0].Raw)
+	if err != nil {
+		t.Fatalf("analyze: %v", err)
+	}
+	return res
+}
+
+func colByName(res core.PrepareResult, name string) (core.Column, bool) {
+	for _, c := range res.Columns {
+		if c.Name == name {
+			return c, true
+		}
+	}
+	return core.Column{}, false
+}
+
+const eventsDDL = `
+CREATE TABLE events (
+	id UInt64,
+	name String,
+	tag Nullable(String),
+	amount Decimal(18, 4)
+) ENGINE = MergeTree ORDER BY id
+`
+
+func TestClickHouseSelectColumns(t *testing.T) {
+	res := analyzeOne(t, eventsDDL, `SELECT id, name, tag FROM events`)
+
+	if len(res.Columns) != 3 {
+		t.Fatalf("got %d cols, want 3: %+v", len(res.Columns), res.Columns)
+	}
+
+	id, ok := colByName(res, "id")
+	if !ok || id.DataType != "uint64" || !id.NotNull {
+		t.Errorf("id: %+v (ok=%v)", id, ok)
+	}
+	name, ok := colByName(res, "name")
+	if !ok || name.DataType != "string" || !name.NotNull {
+		t.Errorf("name: %+v (ok=%v)", name, ok)
+	}
+	// Nullable(String) must resolve to the inner scalar and be nullable.
+	tag, ok := colByName(res, "tag")
+	if !ok || tag.DataType != "string" || tag.NotNull {
+		t.Errorf("tag: want string/nullable, got %+v (ok=%v)", tag, ok)
+	}
+
+	for _, c := range res.Columns {
+		if c.SourceClassOID == 0 || c.SourceAttributeOID == 0 {
+			t.Errorf("col %s missing source binding: %+v", c.Name, c)
+		}
+	}
+}
+
+func TestClickHouseSelectStar(t *testing.T) {
+	res := analyzeOne(t, eventsDDL, `SELECT * FROM events`)
+	if len(res.Columns) != 4 {
+		t.Fatalf("got %d cols, want 4: %+v", len(res.Columns), res.Columns)
+	}
+	want := []string{"id", "name", "tag", "amount"}
+	for i, w := range want {
+		if res.Columns[i].Name != w {
+			t.Errorf("col %d: got %q, want %q", i, res.Columns[i].Name, w)
+		}
+	}
+}

internal/engine/clickhouse/convert.go

@@ -1,6 +1,7 @@
 package clickhouse
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -825,15 +826,14 @@ func (c *cc) convertColumnDeclaration(n *chast.ColumnDeclaration) *ast.ColumnDef
 	}
 
 	if n.Type != nil {
+		// Render the full type text (including nested type parameters such
+		// as the inner type of Nullable(T) / Array(T) and the precision of
+		// Decimal(P, S)) into Name so downstream consumers can recover the
+		// complete declaration. Nested type parameters are themselves
+		// *chast.DataType nodes, which the generic expression converter
+		// cannot represent, so they are rendered here instead.
 		colDef.TypeName = &ast.TypeName{
-			Name: n.Type.Name,
-		}
-		// Handle type parameters (e.g., Decimal(10, 2))
-		if len(n.Type.Parameters) > 0 {
-			colDef.TypeName.Typmods = &ast.List{}
-			for _, param := range n.Type.Parameters {
-				colDef.TypeName.Typmods.Items = append(colDef.TypeName.Typmods.Items, c.convertExpr(param))
-			}
+			Name: renderDataType(n.Type),
 		}
 	}
 
@@ -855,6 +855,42 @@ func (c *cc) convertColumnDeclaration(n *chast.ColumnDeclaration) *ast.ColumnDef
 	return colDef
 }
 
+// renderDataType renders a ClickHouse type node back to its canonical
+// textual form, e.g. Nullable(String), Array(UInt64), Decimal(18, 4), or
+// Map(String, Array(Nullable(UInt32))). Nested type parameters recurse.
+func renderDataType(dt *chast.DataType) string {
+	if dt == nil {
+		return ""
+	}
+	if len(dt.Parameters) == 0 {
+		return dt.Name
+	}
+	parts := make([]string, 0, len(dt.Parameters))
+	for _, p := range dt.Parameters {
+		parts = append(parts, renderTypeParam(p))
+	}
+	return dt.Name + "(" + strings.Join(parts, ", ") + ")"
+}
+
+// renderTypeParam renders a single type parameter: a nested type, a
+// numeric/string literal (Decimal precision, FixedString length, Enum
+// value), or an identifier.
+func renderTypeParam(e chast.Expression) string {
+	switch v := e.(type) {
+	case *chast.DataType:
+		return renderDataType(v)
+	case *chast.Literal:
+		if v.Source != "" {
+			return v.Source
+		}
+		return fmt.Sprintf("%v", v.Value)
+	case *chast.Identifier:
+		return strings.Join(v.Parts, ".")
+	default:
+		return ""
+	}
+}
+
 func (c *cc) convertUpdateQuery(n *chast.UpdateQuery) *ast.UpdateStmt {
 	rv := &ast.RangeVar{
 		Relname: &n.Table,