feat(mssql): support core query constructs and sqlc macros

docs/reference/macros.md

@@ -115,5 +115,8 @@ WHERE age IN (/*SLICE:ages*/?)
 Since the `/*SLICE:ages*/` placeholder is dynamically replaced on a per-query
 basis, this macro can't be used with prepared statements.
 
+On SQL Server the placeholder is `/*SLICE:ages*/@ages`, and each value is bound
+to its own `@p<n>` parameter, the name go-mssqldb gives an unnamed argument.
+
 See a full example in [Passing a slice as a parameter to a
 query](../howto/select.md#mysql-and-sqlite).

internal/codegen/golang/imports.go

@@ -439,9 +439,16 @@ func (i *importer) queryImports(filename string) fileImports {
 		return false
 	}
 
-	// A query bound by name passes sql.Named arguments.
+	// A query bound by name passes sql.Named arguments, except for its
+	// slices, whose values it binds to numbered placeholders.
 	for _, q := range gq {
-		if q.Arg.NamedArgs && !q.Arg.isEmpty() {
+		if !q.Arg.NamedArgs || q.Arg.isEmpty() {
+			continue
+		}
+		if q.Arg.HasSqlcSlices() {
+			std["strconv"] = struct{}{}
+		}
+		if q.Arg.hasNamedArg() {
 			std["database/sql"] = struct{}{}
 		}
 	}
@@ -454,6 +461,7 @@ func (i *importer) queryImports(filename string) fileImports {
 	if sqlcSliceScan() && !sqlpkg.IsPGX() {
 		std["strings"] = struct{}{}
 	}
+
 	if sliceScan() && usesPqArrays(i.Engine, sqlpkg) {
 		pkg[ImportSpec{Path: "github.com/lib/pq"}] = struct{}{}
 	}

internal/codegen/golang/query.go

@@ -157,6 +157,12 @@ func (v QueryValue) namedArg(name, expr string) string {
 	return "sql.Named(" + strconv.Quote(name) + ", " + expr + ")"
 }
 
+// NamedArgForField is the argument expr passed for a field of a query bound
+// by name.
+func (v QueryValue) NamedArgForField(f Field) string {
+	return v.namedArg(f.ParamName, v.VariableForField(f))
+}
+
 func (v QueryValue) Params() string {
 	if v.isEmpty() {
 		return ""
@@ -224,6 +230,20 @@ func (v QueryValue) HasSqlcSlices() bool {
 	return false
 }
 
+// hasNamedArg reports whether any parameter is passed as sql.Named, which a
+// sqlc.slice() never is.
+func (v QueryValue) hasNamedArg() bool {
+	if v.Struct == nil {
+		return !v.HasSqlcSlices()
+	}
+	for _, f := range v.Struct.Fields {
+		if !f.HasSqlcSlice() {
+			return true
+		}
+	}
+	return false
+}
+
 func (v QueryValue) Scan() string {
 	var out []string
 	if v.Struct == nil {

internal/codegen/golang/templates/stdlib/queryCode.tmpl

@@ -131,7 +131,20 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}
         {{- if .Arg.Struct }}
             {{- $arg := .Arg }}
             {{- range .Arg.Struct.Fields }}
-                {{- if .HasSqlcSlice }}
+                {{- if and .HasSqlcSlice $arg.NamedArgs }}
+                    {{- /* The driver names an unnamed argument @p<ordinal>, its
+                        1-based position in queryParams. */}}
+                    if len({{$arg.VariableForField .}}) > 0 {
+                      var placeholders []string
+                      for _, v := range {{$arg.VariableForField .}} {
+                        queryParams = append(queryParams, v)
+                        placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams)))
+                      }
+                      query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", strings.Join(placeholders, ","))
+                    } else {
+                      query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", "NULL")
+                    }
+                {{- else if .HasSqlcSlice }}
                     if len({{$arg.VariableForField .}}) > 0 {
                       for _, v := range {{$arg.VariableForField .}} {
                         queryParams = append(queryParams, v)
@@ -140,6 +153,8 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}
                     } else {
                       query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/?", "NULL", 1)
                     }
+                {{- else if $arg.NamedArgs }}
+                  queryParams = append(queryParams, {{$arg.NamedArgForField .}})
                 {{- else }}
                   queryParams = append(queryParams, {{$arg.VariableForField .}})
                 {{- end }}
@@ -149,6 +164,18 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}
                 in a struct), because .Arg.HasSqlcSlices further up above was true,
                 this section is 100% a slice (impossible to get here otherwise).
             */}}
+            {{- if .Arg.NamedArgs }}
+            if len({{.Arg.Name}}) > 0 {
+              var placeholders []string
+              for _, v := range {{.Arg.Name}} {
+                queryParams = append(queryParams, v)
+                placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams)))
+              }
+              query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", strings.Join(placeholders, ","))
+            } else {
+              query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", "NULL")
+            }
+            {{- else }}
             if len({{.Arg.Name}}) > 0 {
               for _, v := range {{.Arg.Name}} {
                 queryParams = append(queryParams, v)
@@ -157,6 +184,7 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}
             } else {
               query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/?", "NULL", 1)
             }
+            {{- end }}
         {{- end }}
         {{- if emitPreparedQueries }}
         {{ queryRetval . }} {{ queryMethod . }}(ctx, nil, query, queryParams...)

internal/compiler/expand.go

@@ -66,13 +66,21 @@ func (c *Compiler) quoteIdent(ident string) string {
 			return c.quote(ident)
 		}
 	}
+	// A column PIVOT names after a value, as [2023], is no regular
+	// identifier.
+	if c.conf.Engine == config.EngineMSSQL && !validPostgresIdent.MatchString(strings.ToLower(ident)) {
+		return c.quote(ident)
+	}
 	return ident
 }
 
 func (c *Compiler) quote(x string) string {
 	switch c.conf.Engine {
 	case config.EngineMySQL:
 		return "`" + x + "`"
+	case config.EngineMSSQL:
+		// Brackets quote whatever QUOTED_IDENTIFIER is set to.
+		return "[" + strings.ReplaceAll(x, "]", "]]") + "]"
 	default:
 		return "\"" + x + "\""
 	}
@@ -98,9 +106,15 @@ func (c *Compiler) starOldFunc(parts []string) func(string) int {
 			if hasSeparator := i > 0; hasSeparator {
 				length++
 			}
+			// Use the original identifier below: o may already be quoted by
+			// quoteIdent, and quoting it again would measure a different name.
 			if strings.HasPrefix(s[length:], o) {
 				length += len(o)
-			} else if quoted := c.quote(o); strings.HasPrefix(s[length:], quoted) {
+			} else if quoted := c.quote(parts[i]); strings.HasPrefix(s[length:], quoted) {
+				length += len(quoted)
+			} else if quoted := `"` + strings.ReplaceAll(parts[i], `"`, `""`) + `"`; strings.HasPrefix(s[length:], quoted) {
+				// SQL Server quotes with brackets, but reads double quotes
+				// as an identifier too.
 				length += len(quoted)
 			} else {
 				length += len(o)

internal/compiler/parse_core.go

@@ -64,6 +64,7 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess.
 		for _, col := range res.Columns {
 			cols = append(cols, coreColumn(col))
 		}
+		cols = embedColumns(raw, cols, res.Stars, pre.Embeds, c.coreCatalog)
 		placeholders, err := placeholderNames(raw)
 		if err != nil {
 			return nil, err
@@ -105,6 +106,84 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess.
 	}, nil
 }
 
+// embedColumns restores sqlc.embed() grouping after the preprocessor rewrites
+// each macro to table.* and core analysis expands that star into columns. The
+// table is the columns' source, so an embed of an alias names the table behind
+// it. The struct scans every column of the table in order, so only an
+// expansion that is exactly those columns is folded; any other stays flat.
+func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, embeds preprocess.EmbedSet, cat *core.Catalog) []*Column {
+	sel, ok := raw.Stmt.(*ast.SelectStmt)
+	if !ok || len(embeds) == 0 || sel.TargetList == nil {
+		return cols
+	}
+	width := map[int]int{}
+	for _, star := range stars {
+		width[star.Location] = len(star.Columns)
+	}
+	var out []*Column
+	i := 0
+	for _, item := range sel.TargetList.Items {
+		res, ok := item.(*ast.ResTarget)
+		if !ok {
+			return cols
+		}
+		ref, ok := res.Val.(*ast.ColumnRef)
+		if !ok || !hasStarRef(ref) {
+			out = append(out, cols[i])
+			i++
+			continue
+		}
+		n, ok := width[res.Location]
+		if !ok || i+n > len(cols) {
+			return cols
+		}
+		if embed, ok := embeds.Find(ref.Location, res.Location); ok && n > 0 && isWholeTable(cat, cols[i:i+n]) {
+			out = append(out, &Column{Name: embed.Table.Name, EmbedTable: cols[i].Table})
+		} else {
+			out = append(out, cols[i:i+n]...)
+		}
+		i += n
+	}
+	return out
+}
+
+// isWholeTable reports whether cols are every column of one table, in the
+// table's order, each as nullable as the table's: the optional side of an
+// outer join is not, and the table's model could not hold its NULLs.
+func isWholeTable(cat *core.Catalog, cols []*Column) bool {
+	table := cols[0].Table
+	if table == nil {
+		return false
+	}
+	schema := table.Schema
+	if schema == "" {
+		schema = "public"
+	}
+	nsOID, err := cat.NamespaceOID(schema)
+	if err != nil {
+		return false
+	}
+	classOID, err := cat.ClassOID(nsOID, table.Name)
+	if err != nil {
+		return false
+	}
+	tableCols, err := cat.ClassColumns(classOID)
+	if err != nil {
+		return false
+	}
+	i := 0
+	for _, tc := range tableCols {
+		if tc.Hidden {
+			continue
+		}
+		if i >= len(cols) || cols[i].Table == nil || *cols[i].Table != *table || cols[i].OriginalName != tc.Name || cols[i].NotNull != tc.NotNull {
+			return false
+		}
+		i++
+	}
+	return i == len(cols)
+}
+
 func coreColumn(c core.Column) *Column {
 	col := &Column{
 		Name:     c.Name,

internal/core/analyzer/analyzer.go

@@ -2,9 +2,11 @@ package analyzer
 
 import (
 	"fmt"
+	"maps"
 
 	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+	"github.com/sqlc-dev/sqlc/internal/sql/astutils"
 )
 
 func Prepare(cat *core.Catalog, stmt ast.Node) (core.PrepareResult, error) {
@@ -65,6 +67,10 @@ type analyzer struct {
 	// resolving guards against an alias that refers to itself.
 	resolving map[string]bool
 
+	// returning maps the names a RETURNING list may give the statement's
+	// target to the target's own, while that list is analyzed.
+	returning map[string]string
+
 	// stars are the expansions every star in the statement asked for, shared
 	// with the analyzers of the queries nested in it so one statement reports
 	// all of them.
@@ -82,10 +88,16 @@ func (a *analyzer) recordStar(s core.StarExpansion) {
 // placeholder inside the subquery is reported with the rest, and it sees this
 // query's scope, so a correlated reference resolves.
 func (a *analyzer) subquery(s *ast.SelectStmt) (*analyzer, error) {
+	// A set operation, or a query with no FROM, binds no relations of its
+	// own, so what is nested in it sees the query it is nested in.
+	outer := a.scope
+	if outer == nil || len(outer.rels) == 0 {
+		outer = a.outer
+	}
 	sub := &analyzer{
 		cat:    a.cat,
 		params: a.params,
-		outer:  a.scope,
+		outer:  outer,
 		ctes:   a.ctes,
 		stars:  a.stars,
 	}
@@ -291,6 +303,12 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error {
 	if with == nil {
 		return nil
 	}
+	// The analyzers of nested queries share the map they inherit, so a WITH
+	// clause binds its names in a copy, out of sight of the enclosing query.
+	a.ctes = maps.Clone(a.ctes)
+	if a.ctes == nil {
+		a.ctes = map[string]scopeRel{}
+	}
 	for _, item := range listItems(with.Ctes) {
 		cte, ok := item.(*ast.CommonTableExpr)
 		if !ok || cte.Ctename == nil {
@@ -300,20 +318,52 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error {
 		if !ok {
 			continue
 		}
+		// A recursive CTE refers to itself in the branches after its first,
+		// which gives the columns, so the first is bound before the rest.
+		recursive := with.Recursive && sel.Larg != nil && refersTo(sel.Rarg, *cte.Ctename)
+		if recursive {
+			anchor := sel
+			for anchor.Larg != nil {
+				anchor = anchor.Larg
+			}
+			cols, err := a.subqueryColumns(anchor)
+			if err != nil {
+				return fmt.Errorf("with %s: %w", *cte.Ctename, err)
+			}
+			rel := derivedRel(*cte.Ctename, cols)
+			renameColumns(&rel, cte.Aliascolnames)
+			a.ctes[*cte.Ctename] = rel
+		}
 		cols, err := a.subqueryColumns(sel)
 		if err != nil {
 			return fmt.Errorf("with %s: %w", *cte.Ctename, err)
 		}
 		rel := derivedRel(*cte.Ctename, cols)
 		renameColumns(&rel, cte.Aliascolnames)
-		if a.ctes == nil {
-			a.ctes = map[string]scopeRel{}
+		// A recursive CTE's output no longer has one source column. SQL
+		// Server also reports all of its columns as nullable.
+		if recursive {
+			for i := range rel.cols {
+				rel.cols[i].AttOID = 0
+				if a.cat.RecursiveCTEsNullable() {
+					rel.cols[i].NotNull = false
+				}
+			}
 		}
 		a.ctes[*cte.Ctename] = rel
 	}
 	return nil
 }
 
+// refersTo reports whether a query reads the relation named name.
+func refersTo(n ast.Node, name string) bool {
+	found := astutils.Search(n, func(n ast.Node) bool {
+		rv, ok := n.(*ast.RangeVar)
+		return ok && rv.Relname != nil && *rv.Relname == name && (rv.Schemaname == nil || *rv.Schemaname == "")
+	})
+	return len(found.Items) > 0
+}
+
 // bindAliases records the output names the target list assigns, so a later
 // clause can refer to a result column by name.
 func (a *analyzer) bindAliases(targets *ast.List) {