Bind named placeholders from the compiler, scan DuckDB lists and ClickHouse nullables correctly

A parameter whose placeholder names it, SQL Server's and Spanner's @name
and ClickHouse's {name:Type}, is now marked by the compiler: the mssql
and googlesql converters carry the name on the ParamRef as the ClickHouse
one already did, the analyzer keeps it whichever use of the parameter it
sees first, and the plugin Parameter gains a named field. The Go codegen
reads that instead of searching the query text for "@name", which bound
a CAST-wrapped @A positionally, because the analyzer had named it after
the column it was compared with, and matched "@id" inside "@identity_no".

A row struct is scanned into and a params struct is passed as arguments,
and DuckDB wants different types for the two: a list is duckdb.Composite
when scanned and a plain slice when passed. Row structs used the params
form. The imports for the element of a generic type such as
duckdb.Composite[[]time.Time] were also missing, and sql.Named's
database/sql import reached the querier interface, which does not use it.

clickhouse-go dereferences a Nullable value only when Nullable is the
column's outermost type, so LowCardinality(Nullable(T)) and
SimpleAggregateFunction(f, Nullable(T)) come through as pointers that a
sql.Null wrapper cannot scan; they take the pointer form now.

sqlc-test-setup start skips SQL Server wherever install did, rather than
failing on an Ubuntu release the packages are not published for.

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

Author: claude

cmd/sqlc-test-setup/mssql.go

@@ -45,13 +45,9 @@ func installMSSQL() error {
 		return nil
 	}
 
-	ubuntu, err := ubuntuRelease()
+	ubuntu, err := mssqlSupported()
 	if err != nil {
-		log.Printf("sql server packages are published for Ubuntu only, skipping: %s", err)
-		return nil
-	}
-	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") || !mssqlUbuntuReleases[ubuntu] {
-		log.Printf("sql server packages are not published for Ubuntu %s on %s/%s, skipping", ubuntu, runtime.GOOS, runtime.GOARCH)
+		log.Printf("skipping: %s", err)
 		return nil
 	}
 
@@ -106,6 +102,19 @@ func installMSSQL() error {
 	return nil
 }
 
+// mssqlSupported reports whether Microsoft publishes SQL Server packages
+// for this machine, returning its Ubuntu release, and otherwise why not.
+func mssqlSupported() (string, error) {
+	ubuntu, err := ubuntuRelease()
+	if err != nil {
+		return "", fmt.Errorf("sql server packages are published for Ubuntu only: %w", err)
+	}
+	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") || !mssqlUbuntuReleases[ubuntu] {
+		return "", fmt.Errorf("sql server packages are not published for Ubuntu %s on %s/%s", ubuntu, runtime.GOOS, runtime.GOARCH)
+	}
+	return ubuntu, nil
+}
+
 // ubuntuRelease reads the Ubuntu release from /etc/os-release.
 func ubuntuRelease() (string, error) {
 	data, err := os.ReadFile("/etc/os-release")
@@ -144,8 +153,8 @@ func startMSSQL() error {
 		return nil
 	}
 	if _, err := os.Stat(mssqlServer); err != nil {
-		if _, err := ubuntuRelease(); err != nil || runtime.GOOS != "linux" {
-			log.Println("sql server is not installed on this platform, skipping")
+		if _, err := mssqlSupported(); err != nil {
+			log.Printf("sql server is not installed here, skipping: %s", err)
 			return nil
 		}
 		return fmt.Errorf("sql server is not installed: run `sqlc-test-setup install mssql` first")

internal/cmd/shim.go

@@ -258,6 +258,7 @@ func pluginQueryParam(p compiler.Parameter) *plugin.Parameter {
 	return &plugin.Parameter{
 		Number: int32(p.Number),
 		Column: pluginQueryColumn(p.Column),
+		Named:  p.Named,
 	}
 }
 

internal/codegen/golang/clickhouse_type.go

@@ -38,15 +38,22 @@ func clickhouseGoType(options *opts.Options, t *plugin.TypeExpr, nullable, neste
 		}
 		return "any"
 
+	// The driver hands database/sql a Nullable value as a pointer, and
+	// dereferences it only when Nullable is the column's outermost type.
+	// Wrapped in LowCardinality or SimpleAggregateFunction the pointer
+	// comes through as is, which a sql.Null wrapper cannot scan, so a
+	// nullable one takes the pointer form the nested types do.
 	case "lowcardinality":
 		if inner := typeExprArg(t, 0); inner != nil {
-			return clickhouseGoType(options, inner, nullable || inner.Nullable, nested)
+			wrapped := nullable || t.Nullable || inner.Nullable
+			return clickhouseGoType(options, inner, wrapped, nested || wrapped)
 		}
 		return "any"
 
 	case "simpleaggregatefunction":
 		if inner := typeExprLastArg(t); inner != nil {
-			return clickhouseGoType(options, inner, nullable || inner.Nullable, nested)
+			wrapped := nullable || t.Nullable || inner.Nullable
+			return clickhouseGoType(options, inner, wrapped, nested || wrapped)
 		}
 		return "any"
 

internal/codegen/golang/imports.go

@@ -182,11 +182,6 @@ func buildImports(options *opts.Options, queries []Query, uses func(string) bool
 	if uses("sql.Null") {
 		std["database/sql"] = struct{}{}
 	}
-	for _, q := range queries {
-		if q.Arg.NamedArgs && !q.Arg.isEmpty() {
-			std["database/sql"] = struct{}{}
-		}
-	}
 
 	sqlpkg := parseDriver(options.SqlPackage)
 	for _, q := range queries {
@@ -427,6 +422,13 @@ func (i *importer) queryImports(filename string) fileImports {
 		return false
 	}
 
+	// A query bound by name passes sql.Named arguments.
+	for _, q := range gq {
+		if q.Arg.NamedArgs && !q.Arg.isEmpty() {
+			std["database/sql"] = struct{}{}
+		}
+	}
+
 	if anyNonCopyFrom {
 		std["context"] = struct{}{}
 	}
@@ -544,17 +546,62 @@ func trimSliceAndPointerPrefix(v string) string {
 // hasPrefixIgnoringSliceAndPointerPrefix reports whether the type s names
 // prefix once its slice and pointer prefixes are stripped. A map type names
 // it when its key or its value does, so map[string]decimal.Decimal uses the
-// decimal package.
+// decimal package, and an instantiated generic type names it when the type
+// or one of its arguments does, so duckdb.Composite[[]time.Time] uses both
+// the duckdb and the time packages.
 func hasPrefixIgnoringSliceAndPointerPrefix(s, prefix string) bool {
 	trimmedS := trimSliceAndPointerPrefix(s)
 	trimmedPrefix := trimSliceAndPointerPrefix(prefix)
 	if key, value, ok := splitMapType(trimmedS); ok {
 		return hasPrefixIgnoringSliceAndPointerPrefix(key, trimmedPrefix) ||
 			hasPrefixIgnoringSliceAndPointerPrefix(value, trimmedPrefix)
 	}
+	if typ, args, ok := splitGenericType(trimmedS); ok {
+		if strings.HasPrefix(typ, trimmedPrefix) {
+			return true
+		}
+		for _, arg := range args {
+			if hasPrefixIgnoringSliceAndPointerPrefix(arg, trimmedPrefix) {
+				return true
+			}
+		}
+		return false
+	}
 	return strings.HasPrefix(trimmedS, trimmedPrefix)
 }
 
+// splitGenericType splits an instantiated generic type pkg.Name[A, B] into
+// pkg.Name and its type arguments, matching the brackets so an argument
+// that is itself a slice, a map or a generic type is kept whole.
+func splitGenericType(s string) (string, []string, bool) {
+	open := strings.IndexByte(s, '[')
+	if open <= 0 || !strings.HasSuffix(s, "]") {
+		return "", nil, false
+	}
+	var args []string
+	depth, start := 0, open+1
+	for i := open; i < len(s); i++ {
+		switch s[i] {
+		case '[':
+			depth++
+		case ']':
+			depth--
+			if depth == 0 {
+				if i != len(s)-1 {
+					return "", nil, false
+				}
+				args = append(args, strings.TrimSpace(s[start:i]))
+			}
+		case ',':
+			if depth == 1 {
+				args = append(args, strings.TrimSpace(s[start:i]))
+				start = i + 1
+			}
+		}
+	}
+	return s[:open], args, true
+}
+
 // splitMapType splits map[K]V into K and V, matching the brackets so a key
 // that is itself a map or an array is kept whole.
 func splitMapType(s string) (string, string, bool) {

internal/codegen/golang/result.go

@@ -231,7 +231,7 @@ func buildQueries(req *plugin.GenerateRequest, options *opts.Options, enums []En
 
 		qpl := int(*options.QueryParameterLimit)
 
-		namedArgs := placeholdersAreNamed(req.Settings.Engine, query.Text, query.Params)
+		namedArgs := placeholdersAreNamed(query.Params)
 
 		if len(query.Params) == 1 && qpl != 0 {
 			p := query.Params[0]
@@ -428,7 +428,13 @@ func columnsToStruct(req *plugin.GenerateRequest, options *opts.Options, name st
 			Column: c.Column,
 		}
 		if c.embed == nil {
-			f.Type = qualifyType(goParamType(req, options, c.Column), models, qualifier)
+			// A row struct is scanned into, a params struct is passed as
+			// arguments, and a driver can want different types for the two.
+			if useID {
+				f.Type = qualifyType(goType(req, options, c.Column), models, qualifier)
+			} else {
+				f.Type = qualifyType(goParamType(req, options, c.Column), models, qualifier)
+			}
 		} else {
 			f.Type = qualifyType(c.embed.modelType, models, qualifier)
 			f.EmbedFields = c.embed.fields
@@ -481,27 +487,16 @@ func checkIncompatibleFieldTypes(fields []Field) error {
 }
 
 // placeholdersAreNamed reports whether every parameter of a query is bound
-// by name: SQL Server and Spanner name a parameter @name in the query
-// text, ClickHouse's server-side {name:Type} does the same, and their
-// drivers take such an argument as sql.Named. A query written with ? is
-// bound by position, so nothing is named unless every parameter is.
-func placeholdersAreNamed(engine, text string, params []*plugin.Parameter) bool {
+// by name, which the compiler marks on a parameter whose placeholder names
+// it: SQL Server's and Spanner's @name and ClickHouse's {name:Type}, which
+// their drivers take as sql.Named. A query written with ? is bound by
+// position, so nothing is named unless every parameter is.
+func placeholdersAreNamed(params []*plugin.Parameter) bool {
 	if len(params) == 0 {
 		return false
 	}
 	for _, p := range params {
-		name := p.Column.GetName()
-		if name == "" {
-			return false
-		}
-		var named bool
-		switch engine {
-		case engineMSSQL, engineGoogleSQL:
-			named = strings.Contains(text, "@"+name)
-		case engineClickHouse:
-			named = strings.Contains(text, "{"+name+":")
-		}
-		if !named {
+		if !p.Named || p.Column.GetName() == "" {
 			return false
 		}
 	}

internal/compiler/parse_core.go

@@ -63,7 +63,7 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess.
 			cols = append(cols, coreColumn(col))
 		}
 		for _, p := range res.Parameters {
-			params = append(params, Parameter{Number: p.Number, Column: coreParamColumn(p, namedParams)})
+			params = append(params, Parameter{Number: p.Number, Column: coreParamColumn(p, namedParams), Named: p.Name != ""})
 		}
 		expanded, err = source.Mutate(rawSQL, c.expandCore(raw, res.Stars))
 		if err != nil {

internal/compiler/query.go

@@ -64,4 +64,7 @@ type Query struct {
 type Parameter struct {
 	Number int
 	Column *Column
+	// Named is set when the query binds the parameter by name rather than
+	// by position: its placeholder is @name or {name:Type}.
+	Named bool
 }

internal/core/analyzer/analyzer.go

@@ -254,7 +254,7 @@ func (a *analyzer) typeLimit(n ast.Node) error {
 		if err != nil {
 			return err
 		}
-		a.inferParam(pr.Number, exprType{typeOID: oid})
+		a.inferParam(pr, exprType{typeOID: oid})
 		return nil
 	}
 	_, err := a.typeExpr(n)

internal/core/analyzer/dml.go

@@ -167,7 +167,7 @@ func (a *analyzer) bindValue(rel scopeRel, target *core.ClassColumn, v ast.Node)
 	if target != nil {
 		switch value := v.(type) {
 		case *ast.ParamRef:
-			a.inferParam(value.Number, columnType(rel, *target))
+			a.inferParam(value, columnType(rel, *target))
 			return nil
 		case *ast.A_Const:
 			return nil

internal/core/analyzer/expr.go

@@ -200,20 +200,27 @@ func flattenFields(fields *ast.List) []string {
 	return out
 }
 
-func (a *analyzer) typeParamRef(p *ast.ParamRef) (exprType, error) {
+// param is the parameter p refers to, recorded with the name the
+// placeholder carries, whichever of its uses is seen first.
+func (a *analyzer) param(p *ast.ParamRef) core.Parameter {
 	cur, ok := a.params[p.Number]
 	if !ok {
-		cur = core.Parameter{Number: p.Number, Name: p.Name}
-		a.params[p.Number] = cur
+		cur = core.Parameter{Number: p.Number}
+	}
+	if cur.Name == "" {
+		cur.Name = p.Name
 	}
+	a.params[p.Number] = cur
+	return cur
+}
+
+func (a *analyzer) typeParamRef(p *ast.ParamRef) (exprType, error) {
+	cur := a.param(p)
 	return exprType{typeOID: cur.TypeOID, expr: cur.Type.WithNullable(false), nullable: !cur.NotNull}, nil
 }
 
-func (a *analyzer) inferParam(number int, t exprType) {
-	cur, ok := a.params[number]
-	if !ok {
-		cur = core.Parameter{Number: number}
-	}
+func (a *analyzer) inferParam(p *ast.ParamRef, t exprType) {
+	cur := a.param(p)
 	typed := cur.TypeOID == 0 && cur.Type == nil && (t.typeOID != 0 || t.expr != nil)
 	if typed {
 		cur.TypeOID = t.typeOID
@@ -232,7 +239,7 @@ func (a *analyzer) inferParam(number int, t exprType) {
 			}
 		}
 	}
-	a.params[number] = cur
+	a.params[p.Number] = cur
 }
 
 // nameParamAfter names a placeholder compared with a function call after
@@ -301,19 +308,19 @@ func (a *analyzer) typeAExpr(e *ast.A_Expr) (exprType, error) {
 	}
 
 	if pr, ok := e.Lexpr.(*ast.ParamRef); ok && rightT.typeOID != 0 {
-		a.inferParam(pr.Number, rightT)
+		a.inferParam(pr, rightT)
 		a.nameParamAfter(pr.Number, e.Rexpr)
 		leftT = rightT
 	} else if pr := castParamRef(e.Lexpr); pr != nil {
-		a.inferParam(pr.Number, rightT)
+		a.inferParam(pr, rightT)
 		a.nameParamAfter(pr.Number, e.Rexpr)
 	}
 	if pr, ok := e.Rexpr.(*ast.ParamRef); ok && leftT.typeOID != 0 {
-		a.inferParam(pr.Number, leftT)
+		a.inferParam(pr, leftT)
 		a.nameParamAfter(pr.Number, e.Lexpr)
 		rightT = leftT
 	} else if pr := castParamRef(e.Rexpr); pr != nil {
-		a.inferParam(pr.Number, leftT)
+		a.inferParam(pr, leftT)
 		a.nameParamAfter(pr.Number, e.Lexpr)
 	}
 
@@ -668,7 +675,7 @@ func (a *analyzer) typeOperands(n ast.Node, other exprType) error {
 			return err
 		}
 		if other.typeOID != 0 || other.expr != nil {
-			a.inferParam(pr.Number, other)
+			a.inferParam(pr, other)
 		}
 		return nil
 	}