Make sqlc's ClickHouse analysis agree with ClickHouse

testcheck showed sqlc disagreeing with ClickHouse on every analyze case
that went beyond plain column references. This makes the six ClickHouse
cases match the database byte for byte, and moves the testcheck command
under cmd/testcheck.

Types are carried as expressions. The ClickHouse converter keeps a
column's full spelling in the type name's Spelling, the schema stores it
as the attribute's declared type, and the analysis core writes each
column and parameter a TypeExpr from it, so Array(Nullable(String)),
Map(String, Nullable(UInt8)), Tuple(lat Float64, lon Float64) and
Decimal(10, 2) survive intact. The analyze command prints that
expression when the core produced one.

Functions are typed. A ClickHouse function seed of 581 signatures
replaces the single count() entry, with "$n" naming the type of the nth
argument and never_null marking results that stay non-null. The dialect
declares that functions propagate nullability, that comparisons yield
UInt8 while true is Bool, that LIMIT counts are UInt64, and that an
unconstrained placeholder is Nothing. The analyzer scores overloads,
types ORDER BY, LIMIT and OFFSET, follows IN (SELECT ...) into the
subquery, makes COALESCE null only when every argument is, and names a
placeholder compared with a function call after the function.

The converter gives unaliased expression columns ClickHouse's own names,
such as sum(amount) and plus(id, 1), captures aliases on every node
kind, converts a scalar subquery as a value rather than EXISTS, converts
coalesce and ifNull to COALESCE, handles WITH elements as the parser
produces them, and counts positions from zero so star expansion and
parameter renumbering line up. ClickHouse joins the preprocessed
engines, so sqlc.arg() and sqlc.narg() work with ? binding. A dialect
that names the second id of a join e.id says so in its seed and the
analyzer qualifies such columns.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y6XkyWnx7iJFEb8q3AnYps

Author: claude

internal/cmd/analyze.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/sqlc-dev/sqlc/internal/compiler"
 	"github.com/sqlc-dev/sqlc/internal/config"
+	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/multierr"
 	"github.com/sqlc-dev/sqlc/internal/opts"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
@@ -204,36 +205,16 @@ type analyzedQuery struct {
 }
 
 type analyzedColumn struct {
-	Name  string        `json:"name"`
-	Type  *analyzedType `json:"type,omitempty"`
-	Table string        `json:"table,omitempty"`
+	Name  string         `json:"name"`
+	Type  *core.TypeExpr `json:"type,omitempty"`
+	Table string         `json:"table,omitempty"`
 }
 
 type analyzedParam struct {
 	Number int            `json:"number"`
 	Column analyzedColumn `json:"column"`
 }
 
-// analyzedType writes a type as a call expression: a name applied to
-// arguments that are other types, integers, booleans or strings, each with
-// an optional label, and a nullable flag at whatever depth it applies. An
-// array of text is array(text); a nullable column of it has nullable set on
-// the array node. Names are recorded as the engine reports them and resolve
-// against the catalog afterwards.
-type analyzedType struct {
-	Name     string        `json:"name"`
-	Nullable bool          `json:"nullable,omitempty"`
-	Args     []analyzedArg `json:"args,omitempty"`
-}
-
-type analyzedArg struct {
-	Label  string        `json:"label,omitempty"`
-	Type   *analyzedType `json:"type,omitempty"`
-	Int    *int64        `json:"int,omitempty"`
-	Bool   *bool         `json:"bool,omitempty"`
-	String *string       `json:"string,omitempty"`
-}
-
 func newAnalyzedQuery(q *compiler.Query, includeAST bool) analyzedQuery {
 	aq := analyzedQuery{
 		Name:    q.Metadata.Name,
@@ -270,20 +251,24 @@ func newAnalyzedColumn(col *compiler.Column) analyzedColumn {
 	return ac
 }
 
-// newAnalyzedType builds the type expression the compiler's flat column
-// description amounts to: the data type wrapped in one array node per
-// dimension, with the column's nullability on the outermost node.
-func newAnalyzedType(col *compiler.Column) *analyzedType {
+// newAnalyzedType is the column's type as an expression: the one the
+// analysis core wrote when it did, otherwise the flat description the
+// compiler holds, which is the data type wrapped in one array node per
+// dimension with the column's nullability on the outermost node.
+func newAnalyzedType(col *compiler.Column) *core.TypeExpr {
+	if col.TypeExpr != nil {
+		return col.TypeExpr
+	}
 	if col.DataType == "" {
 		return nil
 	}
-	t := &analyzedType{Name: col.DataType}
+	t := core.ParseTypeExpr(col.DataType)
 	dims := col.ArrayDims
 	if col.IsArray && dims == 0 {
 		dims = 1
 	}
 	for i := 0; i < dims; i++ {
-		t = &analyzedType{Name: "array", Args: []analyzedArg{{Type: t}}}
+		t = &core.TypeExpr{Name: "array", Args: []core.TypeArg{{Type: t}}}
 	}
 	t.Nullable = !col.NotNull
 	return t

internal/compiler/parse_core.go

@@ -105,6 +105,7 @@ func coreColumn(c core.Column) *Column {
 		DataType: c.DataType,
 		NotNull:  c.NotNull,
 		IsArray:  c.IsArray,
+		TypeExpr: c.Type,
 	}
 	// The core reports arrays without dimensions, and codegen renders one
 	// "[]" per dimension.
@@ -129,6 +130,7 @@ func coreParamColumn(p core.Parameter, params *named.ParamSet) *Column {
 		DataType: p.DataType,
 		NotNull:  p.NotNull,
 		IsArray:  p.IsArray,
+		TypeExpr: p.Type,
 	}
 	if p.IsArray {
 		col.ArrayDims = 1

internal/compiler/query.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/metadata"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
@@ -37,6 +38,11 @@ type Column struct {
 	Type       *ast.TypeName
 	EmbedTable *ast.TableName
 
+	// TypeExpr is the type as the analysis core wrote it, with the
+	// arguments and nesting DataType and IsArray flatten away. It is unset
+	// on the legacy path.
+	TypeExpr *core.TypeExpr
+
 	IsSqlcSlice bool // is this sqlc.slice()
 
 	skipTableRequiredCheck bool

internal/core/analysis.go

@@ -53,8 +53,11 @@ type ColumnSource struct {
 }
 
 type Column struct {
-	Name               string        `json:"name"`
-	DataType           string        `json:"data_type"`
+	Name     string `json:"name"`
+	DataType string `json:"data_type"`
+	// Type is the column's type as an expression, carrying what DataType
+	// and IsArray flatten away: arguments, nesting and inner nullability.
+	Type               *TypeExpr     `json:"type,omitempty"`
 	TypeOID            int64         `json:"type_oid,omitempty"`
 	NotNull            bool          `json:"not_null"`
 	IsArray            bool          `json:"is_array,omitempty"`
@@ -73,6 +76,7 @@ type Parameter struct {
 	Number   int           `json:"number"`
 	Name     string        `json:"name,omitempty"`
 	DataType string        `json:"data_type,omitempty"`
+	Type     *TypeExpr     `json:"type,omitempty"`
 	TypeOID  int64         `json:"type_oid,omitempty"`
 	NotNull  bool          `json:"not_null"`
 	IsArray  bool          `json:"is_array,omitempty"`

internal/core/analyzer/analyzer.go

@@ -119,6 +119,20 @@ func derivedRel(alias string, cols []core.Column) scopeRel {
 }
 
 func (a *analyzer) result() core.PrepareResult {
+	// A placeholder nothing constrained takes the dialect's type for one, when
+	// the dialect has such a type.
+	if oid, ok := a.cat.UntypedTypeOID(); ok {
+		for n, p := range a.params {
+			if p.TypeOID == 0 && p.DataType == "" {
+				t := exprType{typeOID: oid, nullable: true}
+				p.TypeOID = oid
+				p.DataType, p.IsArray = a.typeNameOf(t)
+				p.NotNull = false
+				p.Type = a.typeExprOf(t, "")
+				a.params[n] = p
+			}
+		}
+	}
 	res := core.PrepareResult{
 		Command:    a.command,
 		Columns:    a.columns,
@@ -213,9 +227,39 @@ func (a *analyzer) analyzeSelect(s *ast.SelectStmt) error {
 			return err
 		}
 	}
+	for _, item := range listItems(s.SortClause) {
+		if sb, ok := item.(*ast.SortBy); ok {
+			if _, err := a.typeExpr(sb.Node); err != nil {
+				return fmt.Errorf("order by: %w", err)
+			}
+		}
+	}
+	for _, n := range []ast.Node{s.LimitCount, s.LimitOffset} {
+		if err := a.typeLimit(n); err != nil {
+			return fmt.Errorf("limit: %w", err)
+		}
+	}
 	return nil
 }
 
+// typeLimit types a LIMIT or OFFSET count. A bare placeholder there holds
+// whatever the dialect counts rows in.
+func (a *analyzer) typeLimit(n ast.Node) error {
+	if n == nil {
+		return nil
+	}
+	if pr, ok := n.(*ast.ParamRef); ok {
+		oid, err := a.cat.LimitTypeOID()
+		if err != nil {
+			return err
+		}
+		a.inferParam(pr.Number, exprType{typeOID: oid})
+		return nil
+	}
+	_, err := a.typeExpr(n)
+	return err
+}
+
 func (a *analyzer) typeValuesLists(l *ast.List) error {
 	for _, row := range listItems(l) {
 		if _, err := a.typeExpr(row); err != nil {