clickhouse/core: strip comments and remove xqlc references

Remove comments from the Go files authored for this work (catalog core,
analyzer, ClickHouse engine, compile path, codegen type map) and drop the
comments added to the files touched along the way, keeping //go:generate
and //go:embed directives. No remaining references to xqlc.

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

Author: kyleconroy

internal/cmd/shim.go

@@ -225,9 +225,6 @@ 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)
@@ -242,12 +239,6 @@ func codeGenRequest(r *compiler.Result, settings config.CombinedSettings) *plugi
 	}
 }
 
-// pluginCatalogFromCore projects a core.Catalog (the xqlc SQLite-backed
-// catalog) into the plugin.Catalog that codegen consumes to emit models
-// and enums. It reads through the catalog's typed accessors, which are
-// backed by sqlc-generated queries. Projection is best-effort: an
-// unexpected error against the in-memory catalog yields a partial catalog
-// rather than aborting generation.
 func pluginCatalogFromCore(cc *core.Catalog) *plugin.Catalog {
 	var schemas []*plugin.Schema
 

internal/codegen/golang/clickhouse_type.go

@@ -8,10 +8,6 @@ import (
 	"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
@@ -34,7 +30,6 @@ func clickhouseType(req *plugin.GenerateRequest, options *opts.Options, col *plu
 	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")
@@ -47,9 +42,6 @@ func clickhouseType(req *plugin.GenerateRequest, options *opts.Options, col *plu
 	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")
@@ -59,7 +51,6 @@ func clickhouseType(req *plugin.GenerateRequest, options *opts.Options, col *plu
 	}
 }
 
-// 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

internal/compiler/compile.go

@@ -56,8 +56,6 @@ 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 {

internal/compiler/engine.go

@@ -29,9 +29,6 @@ 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
@@ -119,9 +116,6 @@ 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())

internal/compiler/parse.go

@@ -19,8 +19,6 @@ 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)
 	}

internal/compiler/parse_clickhouse.go

@@ -12,12 +12,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/sql/validate"
 )
 
-// parseQueryCore is the analysis path for engines backed by the xqlc core
-// catalog and analyzer (currently ClickHouse). It reuses the shared,
-// engine-agnostic query-metadata parsing but resolves columns and
-// parameters through core/analyzer, never touching the legacy compiler
-// analyze step (inferQuery/outputColumns/parameters) or the
-// analyzer.Analyzer seam.
 func (c *Compiler) parseQueryCore(stmt ast.Node, src string) (*Query, error) {
 	raw, ok := stmt.(*ast.RawStmt)
 	if !ok {
@@ -54,9 +48,6 @@ func (c *Compiler) parseQueryCore(stmt ast.Node, src string) (*Query, error) {
 
 	var cols []*Column
 	var params []Parameter
-	// Only result-shaped statements produce columns/parameters. Non-SELECT
-	// statements (:exec, DDL) currently yield an empty shape; growing the
-	// core analyzer to cover INSERT/UPDATE/DELETE is a follow-up.
 	if _, ok := raw.Stmt.(*ast.SelectStmt); ok {
 		res, err := coreanalyzer.Prepare(c.coreCatalog, raw)
 		if err != nil {
@@ -91,9 +82,6 @@ func (c *Compiler) parseQueryCore(stmt ast.Node, src string) (*Query, error) {
 	}, nil
 }
 
-// coreColumn maps a core.Column (analyzer output) onto the compiler's
-// Column. The type name is carried in DataType; Type is left nil so the
-// codegen shim uses DataType directly.
 func coreColumn(c core.Column) *Column {
 	col := &Column{
 		Name:     c.Name,

internal/compiler/result.go

@@ -9,9 +9,5 @@ type Result struct {
 	Catalog *catalog.Catalog
 	Queries []*Query
 
-	// CoreCatalog, when set, is the xqlc-derived catalog that drives both
-	// analysis and codegen for engines on the core (currently ClickHouse).
-	// When it is non-nil, codegen projects the catalog from it instead of
-	// from Catalog.
 	CoreCatalog *core.Catalog
 }

internal/core/analysis.go

@@ -1,8 +1,5 @@
 package core
 
-// Command identifies the kind of statement that produced a PrepareResult.
-// Only the four DML statements that can have a prepare-able shape are
-// emitted; DDL and TCL produce an empty result with Command == "".
 type Command string
 
 const (
@@ -12,40 +9,19 @@ const (
 	CommandDelete Command = "DELETE"
 )
 
-// PrepareResult describes the output of preparing a SQL statement.
 type PrepareResult struct {
 	Command    Command     `json:"command,omitempty"`
 	Columns    []Column    `json:"columns"`
 	Parameters []Parameter `json:"parameters"`
 }
 
-// ColumnSource identifies the table column a result column or bind
-// parameter is sourced from. All fields are optional; the struct is
-// emitted only when at least one is populated.
-//
-// Schema / Table / Column are the *origin* identifiers (pre-alias) —
-// they correspond to sqlite's `sqlite3_column_origin_name` and mysql's
-// `org_table` / `org_name`. TableAlias is the name the query used to
-// refer to the table; it lets codegen distinguish `t1` from `t2` in
-// `SELECT t1.x, t2.x FROM t t1 JOIN t t2 ...`.
 type ColumnSource struct {
 	Schema     string `json:"schema,omitempty"`
 	Table      string `json:"table,omitempty"`
 	TableAlias string `json:"table_alias,omitempty"`
 	Column     string `json:"column,omitempty"`
 }
 
-// Column describes a single output column from a prepared statement.
-//
-// SourceClassOID and SourceAttributeOID are populated when the column
-// is a direct reference to a table column (i.e. it appears in
-// sql_attribute); they are zero for computed/derived expressions like
-// aggregates or arithmetic. Source is the human-readable resolution of
-// those OIDs and is populated under the same conditions.
-//
-// DeclType, TypeLength, TypeScale, IsPrimaryKey, IsUnique, and
-// IsAutoIncrement come from the resolved source attribute and are zero
-// for computed expressions.
 type Column struct {
 	Name               string        `json:"name"`
 	DataType           string        `json:"data_type"`
@@ -62,15 +38,6 @@ type Column struct {
 	IsAutoIncrement    bool          `json:"is_auto_increment,omitempty"`
 }
 
-// Parameter describes a bind parameter in a prepared statement.
-//
-// Number is the 1-based position of the parameter as it appeared in the
-// source ($1, $2, ...). Name is populated for named-parameter dialects
-// or when a sqlc-style "-- name:" annotation gave the param a name; it
-// is empty otherwise. DataType / TypeOID / NotNull come from the
-// resolved usage site (an operator overload, function argument, etc.).
-// Source identifies the column the parameter binds against (e.g.
-// `users.age` for `WHERE age > $1`), when one can be inferred.
 type Parameter struct {
 	Number   int           `json:"number"`
 	Name     string        `json:"name,omitempty"`

internal/core/analyzer/analyzer.go

@@ -1,10 +1,3 @@
-// Package analyzer implements a dialect-neutral SQL query analyzer that
-// resolves names, types, operators, and parameters by querying the
-// catalog (core.Catalog). It produces a core.PrepareResult.
-//
-// Scope is intentionally narrow in this iteration: single-relation SELECT
-// queries, simple WHERE / GROUP BY / projection. JOINs, subqueries,
-// CTEs, set ops, and DML RETURNING are intended follow-ups.
 package analyzer
 
 import (
@@ -14,10 +7,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 )
 
-// Prepare walks a parsed statement and produces a PrepareResult by
-// querying the catalog for relations, types, operators, and casts.
-// stmt can be a *ast.RawStmt (typical parser output) or an unwrapped
-// statement node.
 func Prepare(cat *core.Catalog, stmt ast.Node) (core.PrepareResult, error) {
 	if rs, ok := stmt.(*ast.RawStmt); ok {
 		stmt = rs.Stmt
@@ -80,8 +69,6 @@ func (a *analyzer) analyzeSelect(s *ast.SelectStmt) error {
 	}
 	a.scope = sc
 
-	// Join ON conditions get typed against the (already-assembled)
-	// scope so they can reference columns from either side.
 	for _, item := range listItems(s.FromClause) {
 		if err := a.typeJoinConditions(item); err != nil {
 			return fmt.Errorf("join: %w", err)
@@ -129,9 +116,6 @@ func listItems(l *ast.List) []ast.Node {
 	return l.Items
 }
 
-// typeJoinConditions walks a FROM-list item and types every join's ON
-// expression. USING clauses are skipped — the columns they reference
-// already exist in scope, no expression to type.
 func (a *analyzer) typeJoinConditions(item ast.Node) error {
 	je, ok := item.(*ast.JoinExpr)
 	if !ok {

internal/core/analyzer/analyzer_test.go

@@ -9,10 +9,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
 )
 
-// seedUsers builds a minimal catalog with a single "users" table so the
-// analyzer has something to resolve against. It deliberately avoids any
-// per-dialect seed: the point is to exercise the dialect-neutral
-// analyzer directly on sqlc's ast.
 func seedUsers(t *testing.T) *core.Catalog {
 	t.Helper()
 	cat, err := core.New()
@@ -46,9 +42,6 @@ func seedUsers(t *testing.T) *core.Catalog {
 	return cat
 }
 
-// prepare parses query with sqlc's own PostgreSQL parser — which emits
-// exactly the internal/sql/ast the analyzer was repointed onto — and
-// runs the analyzer against cat.
 func prepare(t *testing.T, cat *core.Catalog, query string) core.PrepareResult {
 	t.Helper()
 	stmts, err := postgresql.NewParser().Parse(strings.NewReader(query))