From 41babf600ac59de6d3787a111a007c66d6c868b2 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:38:59 -0800 Subject: [PATCH 01/74] mssql: make the optional side of outer joins nullable The core analyzer bound every relation in a join with the nullability its columns were declared with, so LEFT, RIGHT and FULL joins reported the optional side as NOT NULL. A new dialect setting, outer_join_nullable, makes those columns nullable. SQL Server turns it on; ClickHouse, which fills unmatched rows with defaults, keeps the old behavior. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/scope.go | 31 +++- internal/core/dialect.go | 15 ++ internal/core/seed/seed.go | 9 ++ .../testdata/mssql_outer_join/mssql/exec.json | 1 + .../testdata/mssql_outer_join/mssql/go/db.go | 31 ++++ .../mssql_outer_join/mssql/go/models.go | 16 ++ .../mssql_outer_join/mssql/go/query.sql.go | 147 ++++++++++++++++++ .../testdata/mssql_outer_join/mssql/query.sql | 11 ++ .../mssql_outer_join/mssql/schema.sql | 10 ++ .../testdata/mssql_outer_join/mssql/sqlc.yaml | 10 ++ internal/engine/mssql/dialect/dialect.json | 1 + 11 files changed, 281 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml diff --git a/internal/core/analyzer/scope.go b/internal/core/analyzer/scope.go index 218a8e0b11..50545466e5 100644 --- a/internal/core/analyzer/scope.go +++ b/internal/core/analyzer/scope.go @@ -52,10 +52,25 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { sc.rels = append(sc.rels, rel) return nil case *ast.JoinExpr: + start := len(sc.rels) if err := a.appendFromItem(sc, v.Larg); err != nil { return err } - return a.appendFromItem(sc, v.Rarg) + mid := len(sc.rels) + if err := a.appendFromItem(sc, v.Rarg); err != nil { + return err + } + if a.cat.OuterJoinsNullable() { + switch v.Jointype { + case ast.JoinTypeLeft: + nullableRels(sc.rels[mid:]) + case ast.JoinTypeRight: + nullableRels(sc.rels[start:mid]) + case ast.JoinTypeFull: + nullableRels(sc.rels[start:]) + } + } + return nil case *ast.RangeFunction: rel, err := a.bindRangeFunction(v) if err != nil { @@ -83,6 +98,20 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { } } +// nullableRels makes every column of rels nullable, as the optional side of +// an outer join is. The columns are copied: a relation's column list is the +// catalog's own. +func nullableRels(rels []scopeRel) { + for i := range rels { + cols := make([]core.ClassColumn, len(rels[i].cols)) + for j, c := range rels[i].cols { + c.NotNull = false + cols[j] = c + } + rels[i].cols = cols + } +} + // bindRangeFunction binds a function called in FROM. A set-returning function // stands in for a relation of a single column named after it. func (a *analyzer) bindRangeFunction(rf *ast.RangeFunction) (scopeRel, error) { diff --git a/internal/core/dialect.go b/internal/core/dialect.go index e192c442c9..e9723c0fb1 100644 --- a/internal/core/dialect.go +++ b/internal/core/dialect.go @@ -77,6 +77,11 @@ const FlagPropagateNullable = "functions.propagate_nullable" // e.id. const FlagQualifyDuplicateColumns = "columns.qualify_duplicates" +// FlagOuterJoinNullable is set for a dialect whose outer joins fill the +// columns of an unmatched side with NULL, as SQL Server's do. ClickHouse's +// fill them with the type's default instead. +const FlagOuterJoinNullable = "joins.outer_nullable" + // FlagDefaultSchema holds the schema the dialect puts an unqualified object // in, when that is not the catalog's own default: a type in it is reported // without its schema. @@ -196,6 +201,16 @@ func (c *Catalog) QualifiesDuplicateColumns() bool { return v == "true" } +// OuterJoinsNullable reports whether the columns of an outer join's +// optional side are nullable. +func (c *Catalog) OuterJoinsNullable() bool { + if c.dialectOID == 0 { + return false + } + v, _ := c.DialectFlag(c.dialectOID, FlagOuterJoinNullable) + return v == "true" +} + // DefaultNamespaces lists the namespaces a type is reported from without // qualification: the catalog's default, PostgreSQL's system catalog, and // the dialect's own default schema when it names one. diff --git a/internal/core/seed/seed.go b/internal/core/seed/seed.go index 064afedae8..daedab961c 100644 --- a/internal/core/seed/seed.go +++ b/internal/core/seed/seed.go @@ -84,6 +84,10 @@ type Settings struct { // ClickHouse names the second id of a join e.id. QualifyDuplicateColumns bool `json:"qualify_duplicate_columns,omitempty"` + // OuterJoinNullable makes the columns of an outer join's optional side + // nullable, as SQL Server fills an unmatched row with NULL. + OuterJoinNullable bool `json:"outer_join_nullable,omitempty"` + // Comparison operators are registered as (T, T) -> Bool for every type in // ComparisonCategories. Comparison []string `json:"comparison,omitempty"` @@ -660,6 +664,11 @@ func (b *builder) consts() error { return err } } + if b.settings.OuterJoinNullable { + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagOuterJoinNullable, "true"); err != nil { + return err + } + } // A schema declares types the seed knows nothing about — enums, domains, // arrays, a SQLite column typed whatever the author felt like. Recording // the comparison operators lets the catalog give those types the same ones. diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json b/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go new file mode 100644 index 0000000000..927a05454c --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go @@ -0,0 +1,16 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Author struct { + ID int64 + Name string +} + +type Book struct { + ID int64 + AuthorID int64 + Title string +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go new file mode 100644 index 0000000000..cb22db28e4 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go @@ -0,0 +1,147 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const fullJoin = `-- name: FullJoin :many +SELECT a.name, b.title FROM authors a FULL OUTER JOIN books b ON b.author_id = a.id; +` + +type FullJoinRow struct { + Name sql.NullString + Title sql.NullString +} + +func (q *Queries) FullJoin(ctx context.Context) ([]FullJoinRow, error) { + rows, err := q.db.QueryContext(ctx, fullJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []FullJoinRow + for rows.Next() { + var i FullJoinRow + if err := rows.Scan(&i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const leftJoin = `-- name: LeftJoin :many +SELECT a.id, a.name, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type LeftJoinRow struct { + ID int64 + Name string + Title sql.NullString +} + +func (q *Queries) LeftJoin(ctx context.Context) ([]LeftJoinRow, error) { + rows, err := q.db.QueryContext(ctx, leftJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []LeftJoinRow + for rows.Next() { + var i LeftJoinRow + if err := rows.Scan(&i.ID, &i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const leftJoinStar = `-- name: LeftJoinStar :many +SELECT a.name, b.id, b.author_id, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type LeftJoinStarRow struct { + Name string + ID sql.NullInt64 + AuthorID sql.NullInt64 + Title sql.NullString +} + +func (q *Queries) LeftJoinStar(ctx context.Context) ([]LeftJoinStarRow, error) { + rows, err := q.db.QueryContext(ctx, leftJoinStar) + if err != nil { + return nil, err + } + defer rows.Close() + var items []LeftJoinStarRow + for rows.Next() { + var i LeftJoinStarRow + if err := rows.Scan( + &i.Name, + &i.ID, + &i.AuthorID, + &i.Title, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const rightJoin = `-- name: RightJoin :many +SELECT a.name, b.title FROM authors a RIGHT JOIN books b ON b.author_id = a.id; +` + +type RightJoinRow struct { + Name sql.NullString + Title string +} + +func (q *Queries) RightJoin(ctx context.Context) ([]RightJoinRow, error) { + rows, err := q.db.QueryContext(ctx, rightJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []RightJoinRow + for rows.Next() { + var i RightJoinRow + if err := rows.Scan(&i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql b/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql new file mode 100644 index 0000000000..c9696e994a --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql @@ -0,0 +1,11 @@ +-- name: LeftJoin :many +SELECT a.id, a.name, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; + +-- name: RightJoin :many +SELECT a.name, b.title FROM authors a RIGHT JOIN books b ON b.author_id = a.id; + +-- name: FullJoin :many +SELECT a.name, b.title FROM authors a FULL OUTER JOIN books b ON b.author_id = a.id; + +-- name: LeftJoinStar :many +SELECT a.name, b.* FROM authors a LEFT JOIN books b ON b.author_id = a.id; diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql b/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql new file mode 100644 index 0000000000..754abf3290 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/engine/mssql/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 30ea408744..41f5e92253 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -8,6 +8,7 @@ "bool": "bit" }, "bool": "bit", + "outer_join_nullable": true, "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="], "comparison_categories": "NBSD", "arithmetic": ["+", "-", "*", "/", "%"], From 81803a4b35a702a9ba477fa39ffbce5e8bc0afd4 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:40:07 -0800 Subject: [PATCH 02/74] mssql: support CROSS APPLY and OUTER APPLY APPLY reached the analyzer as an unconverted node and failed with "unsupported FROM item". Convert it to the join it is: CROSS APPLY to an inner join and OUTER APPLY to a left join. The analyzer already binds each FROM item against the ones before it, so the applied subquery's references to the left side resolve. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_apply/mssql/exec.json | 5 + .../testdata/analyze_apply/mssql/query.sql | 10 ++ .../testdata/analyze_apply/mssql/schema.sql | 10 ++ .../testdata/analyze_apply/mssql/stdout.json | 97 +++++++++++++++++++ internal/engine/mssql/convert.go | 20 ++-- 5 files changed, 136 insertions(+), 6 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_apply/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_apply/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_apply/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_apply/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_apply/mssql/exec.json b/internal/endtoend/testdata/analyze_apply/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_apply/mssql/query.sql b/internal/endtoend/testdata/analyze_apply/mssql/query.sql new file mode 100644 index 0000000000..5362c35b24 --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: LatestBook :many +SELECT a.id, a.name, b.title +FROM authors a +CROSS APPLY (SELECT TOP 1 title FROM books WHERE author_id = a.id ORDER BY id DESC) b; + +-- name: TopBooks :many +SELECT a.name, b.title +FROM authors a +OUTER APPLY (SELECT TOP (@n) title FROM books WHERE author_id = a.id ORDER BY id) b +WHERE a.name = @name; diff --git a/internal/endtoend/testdata/analyze_apply/mssql/schema.sql b/internal/endtoend/testdata/analyze_apply/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_apply/mssql/stdout.json b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json new file mode 100644 index 0000000000..6ba43fceb9 --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json @@ -0,0 +1,97 @@ +[ + { + "name": "LatestBook", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [] + }, + { + "name": "TopBooks", + "cmd": ":many", + "columns": [ + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index bdef335bc6..1fe2cad0d9 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -341,14 +341,22 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { } return join case *tsql.UnqualifiedJoin: - if t.UnqualifiedJoinType != "CrossJoin" { - return todo(ref) + // APPLY is a lateral join: its right side may refer to the left, + // which the analyzer allows for every FROM item bound after another. + // OUTER APPLY keeps unmatched left rows, as a left join does. + join := &ast.JoinExpr{ + Larg: c.convertTableReference(t.FirstTableReference), + Rarg: c.convertTableReference(t.SecondTableReference), } - return &ast.JoinExpr{ - Jointype: ast.JoinTypeInner, - Larg: c.convertTableReference(t.FirstTableReference), - Rarg: c.convertTableReference(t.SecondTableReference), + switch t.UnqualifiedJoinType { + case "CrossJoin", "CrossApply": + join.Jointype = ast.JoinTypeInner + case "OuterApply": + join.Jointype = ast.JoinTypeLeft + default: + return todo(ref) } + return join default: return todo(ref) } From 63e879d2ac933afa71a05d87f167e14a1f918007 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:41:52 -0800 Subject: [PATCH 03/74] mssql: type TOP and OFFSET/FETCH parameters as bigint A placeholder counting rows fell back to the core's default int. SQL Server describes the parameter of TOP (@n), OFFSET @n ROWS and FETCH NEXT @n ROWS as bigint, so the dialect now says so. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_apply/mssql/stdout.json | 2 +- .../testdata/analyze_paging/mssql/exec.json | 5 ++ .../testdata/analyze_paging/mssql/query.sql | 5 ++ .../testdata/analyze_paging/mssql/schema.sql | 7 ++ .../testdata/analyze_paging/mssql/stdout.json | 83 +++++++++++++++++++ internal/engine/mssql/dialect/dialect.json | 1 + 6 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_paging/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_paging/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_paging/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_paging/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_apply/mssql/stdout.json b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json index 6ba43fceb9..927f596197 100644 --- a/internal/endtoend/testdata/analyze_apply/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json @@ -73,7 +73,7 @@ "column": { "name": "n", "type": { - "name": "int" + "name": "bigint" } } }, diff --git a/internal/endtoend/testdata/analyze_paging/mssql/exec.json b/internal/endtoend/testdata/analyze_paging/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_paging/mssql/query.sql b/internal/endtoend/testdata/analyze_paging/mssql/query.sql new file mode 100644 index 0000000000..cb73b7f734 --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: TopAuthors :many +SELECT TOP (@n) id, name FROM authors ORDER BY id; + +-- name: PageAuthors :many +SELECT id, name FROM authors ORDER BY id OFFSET @skip ROWS FETCH NEXT @take ROWS ONLY; diff --git a/internal/endtoend/testdata/analyze_paging/mssql/schema.sql b/internal/endtoend/testdata/analyze_paging/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_paging/mssql/stdout.json b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json new file mode 100644 index 0000000000..5fc257bcbb --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json @@ -0,0 +1,83 @@ +[ + { + "name": "TopAuthors", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "bigint" + } + } + } + ] + }, + { + "name": "PageAuthors", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "skip", + "type": { + "name": "bigint" + } + } + }, + { + "number": 2, + "column": { + "name": "take", + "type": { + "name": "bigint" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 41f5e92253..701b03c3c4 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -8,6 +8,7 @@ "bool": "bit" }, "bool": "bit", + "limit": "bigint", "outer_join_nullable": true, "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="], "comparison_categories": "NBSD", From 0f54b3d9ade29f6a019495eb1f45213b01a41639 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:43:06 -0800 Subject: [PATCH 04/74] mssql: pass the datepart of DATEADD and its relatives as a keyword DATEADD(day, ...), DATEDIFF, DATEPART, DATENAME, DATETRUNC and DATE_BUCKET take a datepart keyword first, which teesql reports as a column reference, so the analyzer failed with unknown column "day". The converter now passes it as the string it names. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_datepart/mssql/exec.json | 5 +++ .../testdata/analyze_datepart/mssql/query.sql | 8 +++++ .../analyze_datepart/mssql/schema.sql | 7 ++++ .../analyze_datepart/mssql/stdout.json | 35 +++++++++++++++++++ internal/engine/mssql/convert.go | 31 +++++++++++++++- 5 files changed, 85 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_datepart/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_datepart/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_datepart/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_datepart/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/exec.json b/internal/endtoend/testdata/analyze_datepart/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql new file mode 100644 index 0000000000..fe22c15579 --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: Recent :many +SELECT id, + DATEADD(day, @days, created) AS due, + DATEDIFF(minute, created, SYSUTCDATETIME()) AS age, + DATEPART(month, created) AS month_of, + DATENAME(weekday, created) AS weekday_of +FROM authors +WHERE created > DATEADD(hour, -1, SYSUTCDATETIME()); diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql b/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json new file mode 100644 index 0000000000..eadcde7994 --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json @@ -0,0 +1,35 @@ +[ + { + "name": "Recent", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "due" + }, + { + "name": "age" + }, + { + "name": "month_of" + }, + { + "name": "weekday_of" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "days" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 1fe2cad0d9..4336b560af 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -742,7 +742,15 @@ func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { AggDistinct: n.UniqueRowFilter == "Distinct", } - for _, param := range n.Parameters { + for i, param := range n.Parameters { + // The datepart DATEADD and its relatives take first is a keyword, + // not a column: it is passed on as the string it names. + if i == 0 && datepartFunctions[identifierValue(n.FunctionName)] { + if part := datepart(param); part != "" { + fc.Args = &ast.List{Items: []ast.Node{&ast.A_Const{Val: &ast.String{Str: part}, Location: c.loc(param)}}} + continue + } + } // COUNT(*) and friends carry the star as a wildcard column reference. if col, ok := param.(*tsql.ColumnReferenceExpression); ok && col.ColumnType == "Wildcard" && col.MultiPartIdentifier == nil { fc.AggStar = true @@ -770,6 +778,27 @@ func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { return fc } +// datepartFunctions are the functions whose first argument is a datepart. +var datepartFunctions = map[string]bool{ + "dateadd": true, + "datediff": true, + "datediff_big": true, + "datename": true, + "datepart": true, + "datetrunc": true, + "date_bucket": true, +} + +// datepart returns the datepart keyword an argument spells, as in +// DATEADD(day, ...), or "" when it is not a bare name. +func datepart(n tsql.ScalarExpression) string { + col, ok := n.(*tsql.ColumnReferenceExpression) + if !ok || col.MultiPartIdentifier == nil || len(col.MultiPartIdentifier.Identifiers) != 1 { + return "" + } + return identifierValue(col.MultiPartIdentifier.Identifiers[0]) +} + // convertOutputClause converts an OUTPUT clause to a returning list. The // INSERTED and DELETED pseudo-table qualifiers are stripped so the columns // resolve against the statement's target table. From 54cc31523c5d4d41f2aac63e59383a45bdd16524 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:44:50 -0800 Subject: [PATCH 05/74] mssql: support recursive common table expressions A CTE that read itself failed: the analyzer bound a CTE only once its whole query was analyzed, so the self-reference named an unknown relation. When a WITH clause is recursive, the anchor member is now bound first and the full query analyzed against it. SQL Server describes every column of a recursive CTE as nullable and read from no table, and so does sqlc. T-SQL has no RECURSIVE keyword, so the converter marks every WITH clause recursive; only a CTE that names itself is treated as one. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 38 ++++++++- .../analyze_recursive_cte/mssql/exec.json | 5 ++ .../analyze_recursive_cte/mssql/query.sql | 18 +++++ .../analyze_recursive_cte/mssql/schema.sql | 5 ++ .../analyze_recursive_cte/mssql/stdout.json | 77 +++++++++++++++++++ internal/engine/mssql/convert.go | 7 +- 6 files changed, 146 insertions(+), 4 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 2bc94d7338..70fa3c81bc 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -5,6 +5,7 @@ import ( "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) { @@ -300,20 +301,53 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error { if !ok { continue } + if a.ctes == nil { + a.ctes = map[string]scopeRel{} + } + // 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{} + // What a recursive CTE yields is the union of every round of it, so + // no column stands for a single table column and any may be NULL. + if recursive { + for i := range rel.cols { + rel.cols[i].AttOID = 0 + 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) { diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json b/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql b/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql new file mode 100644 index 0000000000..bf18662350 --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql @@ -0,0 +1,18 @@ +-- name: Subtree :many +WITH tree AS ( + SELECT id, parent_id, name, 0 AS depth FROM nodes WHERE id = @root + UNION ALL + SELECT n.id, n.parent_id, n.name, t.depth + 1 + FROM nodes n + JOIN tree t ON n.parent_id = t.id +) +SELECT id, parent_id, name, depth FROM tree +OPTION (MAXRECURSION 100); + +-- name: Numbers :many +WITH seq(i) AS ( + SELECT 1 + UNION ALL + SELECT i + 1 FROM seq WHERE i < @max +) +SELECT i FROM seq; diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql b/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql new file mode 100644 index 0000000000..89c256a5ef --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE nodes ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + parent_id BIGINT, + name NVARCHAR(100) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json b/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json new file mode 100644 index 0000000000..f864eb2874 --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json @@ -0,0 +1,77 @@ +[ + { + "name": "Subtree", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "parent_id", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "depth", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "root", + "type": { + "name": "bigint" + }, + "table": "nodes" + } + } + ] + }, + { + "name": "Numbers", + "cmd": ":many", + "columns": [ + { + "name": "i", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "max", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 4336b560af..7c31a59ee3 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -107,9 +107,12 @@ func (c *cc) convertWithClause(n *tsql.WithCtesAndXmlNamespaces) *ast.WithClause if n == nil || len(n.CommonTableExpressions) == 0 { return nil } + // T-SQL has no RECURSIVE keyword: a common table expression that names + // itself is recursive. with := &ast.WithClause{ - Ctes: &ast.List{}, - Location: c.loc(n), + Ctes: &ast.List{}, + Recursive: true, + Location: c.loc(n), } for _, cte := range n.CommonTableExpressions { name := identifierValue(cte.ExpressionName) From b00412c8ca04d5e94b4a26bed6020b232c1e6c50 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:47:37 -0800 Subject: [PATCH 06/74] mssql: support OPENJSON, STRING_SPLIT and GENERATE_SERIES in FROM The table-valued built-ins reached the analyzer unconverted and failed with "unsupported FROM item". The converter now reports each as a range function with a column definition list: OPENJSON's key, value and type, or the columns its WITH clause declares; STRING_SPLIT's value, plus its ordinal when enable_ordinal is passed; GENERATE_SERIES's value. The core analyzer reads a range function's column definition list, where a definition with no type is the function's own result, and a seeded "$n" result over an untyped placeholder takes the parameter's declared type rather than leaking the pseudo-type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/expr.go | 5 + internal/core/analyzer/scope.go | 25 +++ .../analyze_table_functions/mssql/exec.json | 5 + .../analyze_table_functions/mssql/query.sql | 19 +++ .../analyze_table_functions/mssql/schema.sql | 5 + .../analyze_table_functions/mssql/stdout.json | 145 ++++++++++++++++++ .../mssql_string_split_param/mssql/exec.json | 5 + .../mssql_string_split_param/mssql/query.sql | 6 + .../mssql_string_split_param/mssql/schema.sql | 5 + .../mssql/stdout.json | 61 ++++++++ internal/engine/mssql/convert.go | 77 ++++++++++ internal/engine/mssql/dialect/functions.jsonl | 12 ++ 12 files changed, 370 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_table_functions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_table_functions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json create mode 100644 internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json diff --git a/internal/core/analyzer/expr.go b/internal/core/analyzer/expr.go index 62a69b273d..ec7120b96c 100644 --- a/internal/core/analyzer/expr.go +++ b/internal/core/analyzer/expr.go @@ -984,6 +984,11 @@ func (a *analyzer) returnType(p core.ProcOverload, argTypes []exprType) exprType } if n, ok := argIndex(name); ok { if n < len(argTypes) { + // A placeholder passed there takes the parameter's type, and so + // does the result. + if argTypes[n].typeOID == 0 && argTypes[n].expr == nil && n < len(p.ArgTypes) && !a.isPolymorphicOID(p.ArgTypes[n]) { + return exprType{typeOID: p.ArgTypes[n]} + } return exprType{typeOID: argTypes[n].typeOID, expr: argTypes[n].expr} } return exprType{} diff --git a/internal/core/analyzer/scope.go b/internal/core/analyzer/scope.go index 50545466e5..ada3da93eb 100644 --- a/internal/core/analyzer/scope.go +++ b/internal/core/analyzer/scope.go @@ -151,9 +151,34 @@ func (a *analyzer) bindRangeFunction(rf *ast.RangeFunction) (scopeRel, error) { col.TypeOID, col.NotNull = p.ReturnTypeOID, !p.ReturnNullable } rel.cols = []core.ClassColumn{col} + if rf.Coldeflist != nil { + rel.cols = a.coldefColumns(rf.Coldeflist, col) + } return rel, nil } +// coldefColumns are the columns a function's column definition list +// declares, for a function returning rows of more than one column. A +// definition with no type is the function's own result. +func (a *analyzer) coldefColumns(defs *ast.List, result core.ClassColumn) []core.ClassColumn { + var cols []core.ClassColumn + for _, item := range listItems(defs) { + def, ok := item.(*ast.ColumnDef) + if !ok { + continue + } + if def.TypeName == nil { + col := result + col.Name = def.Colname + cols = append(cols, col) + continue + } + t := a.lookupType(core.TypeExprOfTypeName(def.TypeName)) + cols = append(cols, core.ClassColumn{Name: def.Colname, TypeOID: t.typeOID, Type: t.expr, NotNull: def.IsNotNull}) + } + return cols +} + func findFuncCall(l *ast.List) *ast.FuncCall { for _, item := range listItems(l) { switch v := item.(type) { diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_table_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql new file mode 100644 index 0000000000..677428a56e --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql @@ -0,0 +1,19 @@ +-- name: Elements :many +SELECT d.id, j.[key], j.value, j.type +FROM documents d +CROSS APPLY OPENJSON(d.body) j +WHERE d.id = @id; + +-- name: Items :many +SELECT d.id, i.name, i.qty, i.extra +FROM documents d +CROSS APPLY OPENJSON(d.body, '$.items') + WITH (name NVARCHAR(50) '$.name', qty INT '$.qty', extra NVARCHAR(MAX) '$.extra' AS JSON) i; + +-- name: Words :many +SELECT d.id, w.value, w.ordinal +FROM documents d +CROSS APPLY STRING_SPLIT(d.title, N' ', 1) w; + +-- name: Series :many +SELECT value FROM GENERATE_SERIES(1, 10); diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql new file mode 100644 index 0000000000..f70422d2a7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE documents ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + body NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json new file mode 100644 index 0000000000..529f8710d7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json @@ -0,0 +1,145 @@ +[ + { + "name": "Elements", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "key", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "value", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "type", + "type": { + "name": "tinyint" + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + } + } + ] + }, + { + "name": "Items", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "extra", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [] + }, + { + "name": "Words", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "value", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "ordinal", + "type": { + "name": "bigint" + } + } + ], + "params": [] + }, + { + "name": "Series", + "cmd": ":many", + "columns": [ + { + "name": "value", + "type": { + "name": "int" + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json b/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql b/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql new file mode 100644 index 0000000000..16c0c69a27 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql @@ -0,0 +1,6 @@ +-- name: ByIDs :many +SELECT id, title FROM documents +WHERE id IN (SELECT CAST(value AS BIGINT) FROM STRING_SPLIT(@ids, ',')); + +-- name: Tokens :many +SELECT value FROM STRING_SPLIT(@list, ','); diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql b/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql new file mode 100644 index 0000000000..f70422d2a7 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE documents ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + body NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json b/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json new file mode 100644 index 0000000000..430beca540 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json @@ -0,0 +1,61 @@ +[ + { + "name": "ByIDs", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "documents" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "ids", + "type": { + "name": "varchar" + } + } + } + ] + }, + { + "name": "Tokens", + "cmd": ":many", + "columns": [ + { + "name": "value", + "type": { + "name": "varchar" + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "list", + "type": { + "name": "varchar" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 7c31a59ee3..44f167f6d4 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -360,11 +360,88 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { return todo(ref) } return join + case *tsql.OpenJsonTableReference: + return c.convertOpenJson(t) + case *tsql.GlobalFunctionTableReference: + return c.convertGlobalFunctionTableReference(t) default: return todo(ref) } } +// rangeFunction is a call in FROM to a function returning rows of the +// columns defs declares. +func (c *cc) rangeFunction(n tsql.Node, name string, args []tsql.ScalarExpression, alias *tsql.Identifier, defs []ast.Node) *ast.RangeFunction { + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: name}}}, + Location: c.loc(n), + } + for _, arg := range args { + if call.Args == nil { + call.Args = &ast.List{} + } + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(arg)) + } + rf := &ast.RangeFunction{ + Functions: &ast.List{Items: []ast.Node{&ast.List{Items: []ast.Node{call}}}}, + Coldeflist: &ast.List{Items: defs}, + } + if alias != nil { + name := identifierValue(alias) + rf.Alias = &ast.Alias{Aliasname: &name} + } + return rf +} + +// convertOpenJson converts OPENJSON, whose rows are the key, value and type +// of each JSON element, or the columns its WITH clause declares. +func (c *cc) convertOpenJson(n *tsql.OpenJsonTableReference) ast.Node { + args := []tsql.ScalarExpression{n.Variable} + if n.RowPattern != nil { + args = append(args, n.RowPattern) + } + var defs []ast.Node + if len(n.SchemaDeclarationItems) == 0 { + defs = []ast.Node{ + &ast.ColumnDef{Colname: "key", TypeName: typeName("nvarchar", 4000), IsNotNull: true}, + &ast.ColumnDef{Colname: "value", TypeName: &ast.TypeName{Name: "nvarchar", Typmods: appendTypmod(nil, &ast.String{Str: "max"})}}, + &ast.ColumnDef{Colname: "type", TypeName: &ast.TypeName{Name: "tinyint"}, IsNotNull: true}, + } + } + for _, item := range n.SchemaDeclarationItems { + if item.ColumnDefinition == nil { + continue + } + defs = append(defs, &ast.ColumnDef{ + Colname: identifierValue(item.ColumnDefinition.ColumnIdentifier), + TypeName: dataTypeName(item.ColumnDefinition.DataType), + }) + } + return c.rangeFunction(n, "openjson", args, n.Alias, defs) +} + +// convertGlobalFunctionTableReference converts STRING_SPLIT and +// GENERATE_SERIES. Each returns a value of its seeded result type, and +// STRING_SPLIT with enable_ordinal set adds the ordinal of each. +func (c *cc) convertGlobalFunctionTableReference(n *tsql.GlobalFunctionTableReference) ast.Node { + name := identifierValue(n.Name) + defs := []ast.Node{&ast.ColumnDef{Colname: "value"}} + switch name { + case "string_split": + if len(n.Parameters) == 3 { + defs = append(defs, &ast.ColumnDef{Colname: "ordinal", TypeName: &ast.TypeName{Name: "bigint"}, IsNotNull: true}) + } + case "generate_series": + default: + return todo(n) + } + return c.rangeFunction(n, name, n.Parameters, n.Alias, defs) +} + +func typeName(name string, length int64) *ast.TypeName { + return &ast.TypeName{Name: name, Typmods: appendTypmod(nil, &ast.A_Const{Val: &ast.Integer{Ival: length}})} +} + func (c *cc) convertBooleanExpression(expr tsql.BooleanExpression) ast.Node { if expr == nil { return nil diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index e0cd45408c..891d141f36 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -74,3 +74,15 @@ {"name": "rtrim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} {"name": "trim", "args": [{"type": "varchar"}], "returns": "varchar"} {"name": "trim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "openjson", "args": [{"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} +{"name": "openjson", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} +{"name": "string_split", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}, {"type": "int"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "varchar"}, {"type": "varchar"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "int"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "bigint"}, {"type": "bigint"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "decimal"}, {"type": "decimal"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "bigint"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "decimal"}, {"type": "decimal"}, {"type": "decimal"}], "returns": "$1"} From 53bc77328b07170d3cce59a55b471fdfc0237cb7 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:49:34 -0800 Subject: [PATCH 07/74] mssql: type AT TIME ZONE teesql parses x AT TIME ZONE tz, but the converter dropped it, leaving the column untyped. It is now the call of a seeded pseudo-function, so the result is the nullable datetimeoffset SQL Server describes, with datetime's precision of 3, and a time zone placeholder is nvarchar(4000). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_at_time_zone/mssql/exec.json | 5 ++ .../analyze_at_time_zone/mssql/query.sql | 6 ++ .../analyze_at_time_zone/mssql/schema.sql | 7 +++ .../analyze_at_time_zone/mssql/stdout.json | 55 +++++++++++++++++++ internal/engine/mssql/convert.go | 15 +++++ internal/engine/mssql/dialect/functions.jsonl | 4 ++ 6 files changed, 92 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json b/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql b/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql new file mode 100644 index 0000000000..60bb2bd927 --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql @@ -0,0 +1,6 @@ +-- name: CreatedIn :many +SELECT id, + created AT TIME ZONE 'UTC' AS created_utc, + GETDATE() AT TIME ZONE 'UTC' AS now_utc +FROM authors +WHERE created AT TIME ZONE @tz > SYSDATETIMEOFFSET(); diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql b/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json b/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json new file mode 100644 index 0000000000..be5e5a7601 --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json @@ -0,0 +1,55 @@ +[ + { + "name": "CreatedIn", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "created_utc", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + }, + { + "name": "now_utc", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "tz", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 44f167f6d4..7b82d37a20 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -732,6 +732,21 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Subselect: c.convertQueryExpression(e.QueryExpression), Location: c.loc(e), } + case *tsql.AtTimeZoneCall: + // x AT TIME ZONE tz is typed as the call the dialect seeds under a + // name no function can have. + return &ast.FuncCall{ + Funcname: &ast.List{ + Items: []ast.Node{&ast.String{Str: "at time zone"}}, + }, + Args: &ast.List{ + Items: []ast.Node{ + c.convertScalarExpression(e.DateValue), + c.convertScalarExpression(e.TimeZone), + }, + }, + Location: c.loc(e), + } case *tsql.ParameterlessCall: return &ast.FuncCall{ Funcname: &ast.List{ diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 891d141f36..3469b905ac 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -86,3 +86,7 @@ {"name": "generate_series", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "$1"} {"name": "generate_series", "args": [{"type": "bigint"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "$1"} {"name": "generate_series", "args": [{"type": "decimal"}, {"type": "decimal"}, {"type": "decimal"}], "returns": "$1"} +{"name": "at time zone", "args": [{"type": "datetimeoffset"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(7)", "nullable": true} +{"name": "at time zone", "args": [{"type": "datetime2"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(7)", "nullable": true} +{"name": "at time zone", "args": [{"type": "datetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(3)", "nullable": true} +{"name": "at time zone", "args": [{"type": "smalldatetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(0)", "nullable": true} From ebc30aa9b0445caa1cace7629c39a31067f70230 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:46:25 -0800 Subject: [PATCH 08/74] mssql: support sqlc.arg, sqlc.narg and sqlc.slice SQL Server had no preprocessor dialect, so sqlc macros reached the T-SQL parser as function calls and produced no parameter. Add one that rewrites them to native @name placeholders, numbers bare @name alongside them and folds name case as SQL Server does, leaving @@ system functions alone. Named-arg queries cannot expand a slice into positional ?s, so expand it into the @p names go-mssqldb gives unnamed arguments and pass the other parameters through sql.Named. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/reference/macros.md | 3 + internal/codegen/golang/imports.go | 12 +- internal/codegen/golang/query.go | 20 +++ .../golang/templates/stdlib/queryCode.tmpl | 30 +++- .../mssql_sqlc_macros/mssql/exec.json | 1 + .../testdata/mssql_sqlc_macros/mssql/go/db.go | 31 ++++ .../mssql_sqlc_macros/mssql/go/models.go | 21 +++ .../mssql_sqlc_macros/mssql/go/query.sql.go | 150 ++++++++++++++++++ .../mssql_sqlc_macros/mssql/query.sql | 14 ++ .../mssql_sqlc_macros/mssql/schema.sql | 11 ++ .../mssql_sqlc_macros/mssql/sqlc.yaml | 10 ++ internal/sql/preprocess/CLAUDE.md | 1 + internal/sql/preprocess/dialect.go | 9 ++ internal/sql/preprocess/preprocess.go | 20 +++ internal/sql/preprocess/scan.go | 3 +- .../preprocess/testdata/mssql/arg/input.sql | 1 + .../preprocess/testdata/mssql/arg/output.sql | 1 + .../testdata/mssql/arg/side_table.json | 24 +++ .../mssql/at_sign_keeps_spelling/input.sql | 1 + .../mssql/at_sign_keeps_spelling/output.sql | 1 + .../at_sign_keeps_spelling/side_table.json | 30 ++++ .../preprocess/testdata/mssql/embed/input.sql | 1 + .../testdata/mssql/embed/output.sql | 1 + .../testdata/mssql/embed/side_table.json | 24 +++ .../mssql/skip_nested_block_comment/input.sql | 1 + .../skip_nested_block_comment/output.sql | 1 + .../skip_nested_block_comment/side_table.json | 16 ++ .../preprocess/testdata/mssql/slice/input.sql | 1 + .../testdata/mssql/slice/output.sql | 1 + .../testdata/mssql/slice/side_table.json | 24 +++ .../input.sql | 1 + .../output.sql | 1 + .../side_table.json | 28 ++++ 33 files changed, 490 insertions(+), 4 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml create mode 100644 internal/sql/preprocess/testdata/mssql/arg/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/arg/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/arg/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/embed/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/embed/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/embed/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/slice/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/slice/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/slice/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json diff --git a/docs/reference/macros.md b/docs/reference/macros.md index 54d44ed5c9..fb8ac2ebe8 100644 --- a/docs/reference/macros.md +++ b/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` 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). diff --git a/internal/codegen/golang/imports.go b/internal/codegen/golang/imports.go index e1370e48eb..62b59ba7c1 100644 --- a/internal/codegen/golang/imports.go +++ b/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{}{} } diff --git a/internal/codegen/golang/query.go b/internal/codegen/golang/query.go index 6bd9b70e25..363ae6a0b0 100644 --- a/internal/codegen/golang/query.go +++ b/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 { diff --git a/internal/codegen/golang/templates/stdlib/queryCode.tmpl b/internal/codegen/golang/templates/stdlib/queryCode.tmpl index 8fd67f1567..f0fe0189ef 100644 --- a/internal/codegen/golang/templates/stdlib/queryCode.tmpl +++ b/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, 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.Replace(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", strings.Join(placeholders, ","), 1) + } else { + query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", "NULL", 1) + } + {{- 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.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", strings.Join(placeholders, ","), 1) + } else { + query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", "NULL", 1) + } + {{- 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...) diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go new file mode 100644 index 0000000000..4073af03ce --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go @@ -0,0 +1,21 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int64 + Name string + Bio sql.NullString +} + +type Book struct { + ID int64 + AuthorID int64 + Title string +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go new file mode 100644 index 0000000000..6ca10472c2 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go @@ -0,0 +1,150 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" + "strconv" + "strings" +) + +const createAuthor = `-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (@id, @name, @bio); +` + +type CreateAuthorParams struct { + ID int64 + Name string + Bio sql.NullString +} + +func (q *Queries) CreateAuthor(ctx context.Context, arg CreateAuthorParams) error { + _, err := q.db.ExecContext(ctx, createAuthor, sql.Named("id", arg.ID), sql.Named("name", arg.Name), sql.Named("bio", arg.Bio)) + return err +} + +const listAuthorsByIDs = `-- name: ListAuthorsByIDs :many +SELECT id, name FROM authors WHERE id IN (/*SLICE:ids*/@ids) ORDER BY id; +` + +type ListAuthorsByIDsRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDs(ctx context.Context, ids []int64) ([]ListAuthorsByIDsRow, error) { + query := listAuthorsByIDs + var queryParams []any + if len(ids) > 0 { + var placeholders []string + for _, v := range ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.Replace(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ","), 1) + } else { + query = strings.Replace(query, "/*SLICE:ids*/@ids", "NULL", 1) + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsRow + for rows.Next() { + var i ListAuthorsByIDsRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAuthorsByIDsAndName = `-- name: ListAuthorsByIDsAndName :many +SELECT id, name FROM authors WHERE name <> @name AND id IN (/*SLICE:ids*/@ids) AND bio IS NULL ORDER BY id; +` + +type ListAuthorsByIDsAndNameParams struct { + Name string + Ids []int64 +} + +type ListAuthorsByIDsAndNameRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDsAndName(ctx context.Context, arg ListAuthorsByIDsAndNameParams) ([]ListAuthorsByIDsAndNameRow, error) { + query := listAuthorsByIDsAndName + var queryParams []any + queryParams = append(queryParams, sql.Named("name", arg.Name)) + if len(arg.Ids) > 0 { + var placeholders []string + for _, v := range arg.Ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.Replace(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ","), 1) + } else { + query = strings.Replace(query, "/*SLICE:ids*/@ids", "NULL", 1) + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsAndNameRow + for rows.Next() { + var i ListAuthorsByIDsAndNameRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const rowCount = `-- name: RowCount :one +SELECT CAST(@@ROWCOUNT AS INT) AS row_count; +` + +func (q *Queries) RowCount(ctx context.Context) (int32, error) { + row := q.db.QueryRowContext(ctx, rowCount) + var row_count int32 + err := row.Scan(&row_count) + return row_count, err +} + +const updateBio = `-- name: UpdateBio :execrows +UPDATE authors SET bio = @bio WHERE id = @id; +` + +type UpdateBioParams struct { + Bio sql.NullString + ID int64 +} + +func (q *Queries) UpdateBio(ctx context.Context, arg UpdateBioParams) (int64, error) { + result, err := q.db.ExecContext(ctx, updateBio, sql.Named("bio", arg.Bio), sql.Named("id", arg.ID)) + if err != nil { + return 0, err + } + return result.RowsAffected() +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql new file mode 100644 index 0000000000..5de1c42a5d --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql @@ -0,0 +1,14 @@ +-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (sqlc.arg(id), sqlc.arg(name), sqlc.narg(bio)); + +-- name: UpdateBio :execrows +UPDATE authors SET bio = sqlc.narg(bio) WHERE id = @id; + +-- name: ListAuthorsByIDs :many +SELECT id, name FROM authors WHERE id IN (sqlc.slice(ids)) ORDER BY id; + +-- name: ListAuthorsByIDsAndName :many +SELECT id, name FROM authors WHERE name <> @name AND id IN (sqlc.slice(ids)) AND bio IS NULL ORDER BY id; + +-- name: RowCount :one +SELECT CAST(@@ROWCOUNT AS INT) AS row_count; diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql new file mode 100644 index 0000000000..95887bf36e --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE authors ( + id BIGINT PRIMARY KEY, + name NVARCHAR(50) NOT NULL, + bio NVARCHAR(MAX) +); + +CREATE TABLE books ( + id BIGINT PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(100) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/sql/preprocess/CLAUDE.md b/internal/sql/preprocess/CLAUDE.md index a7f4d9aafe..2f8a48f67f 100644 --- a/internal/sql/preprocess/CLAUDE.md +++ b/internal/sql/preprocess/CLAUDE.md @@ -20,6 +20,7 @@ Native placeholders by dialect: | postgresql | `$1` | sqlc syntax | | mysql | `?` | user variable, left alone | | sqlite | `?1` | sqlc syntax | +| mssql | `@name` | native, kept as written; names compare without regard to case | GoogleSQL and ClickHouse are deliberately absent. They handle their own parameter syntax, so `File` returns their source unchanged and sqlc syntax is diff --git a/internal/sql/preprocess/dialect.go b/internal/sql/preprocess/dialect.go index 4d8d4ae85b..4098512086 100644 --- a/internal/sql/preprocess/dialect.go +++ b/internal/sql/preprocess/dialect.go @@ -14,6 +14,8 @@ const ( StyleQuestion // StyleOrdinal numbers parameters as ?1, ?2, ... (SQLite) StyleOrdinal + // StyleAt names parameters as @name (SQL Server) + StyleAt ) // Dialect describes the lexical rules the preprocessor needs to walk a query @@ -88,6 +90,13 @@ var dialects = map[config.Engine]Dialect{ Backtick: true, Backslash: true, }, + // SQL Server's @name is already a named parameter, so sqlc.arg(name) + // becomes one. Its comments nest and its identifiers keep their case. + config.EngineMSSQL: { + Style: StyleAt, + AtSign: true, + NestedBlockComment: true, + }, // ClickHouse binds with an unnumbered ?, like MySQL, and its identifiers // keep their case. config.EngineClickHouse: { diff --git a/internal/sql/preprocess/preprocess.go b/internal/sql/preprocess/preprocess.go index ad25bc9b2f..ff9c92880a 100644 --- a/internal/sql/preprocess/preprocess.go +++ b/internal/sql/preprocess/preprocess.go @@ -347,11 +347,22 @@ func number(d Dialect, occs []occurrence) *named.ParamSet { numbs[occ.number] = true } ps := named.NewParamSet(numbs, d.hasNamedSupport()) + // SQL Server compares parameter names without regard to case, so @Name + // and @name are one parameter, named by its first spelling. + spelling := map[string]string{} for i := range occs { occ := &occs[i] if occ.kind == kindEmbed || occ.kind == kindNative { continue } + if d.Style == StyleAt { + key := strings.ToLower(occ.name) + if first, ok := spelling[key]; ok { + occ.name = first + } else { + spelling[key] = occ.name + } + } occ.number = ps.Add(param(occ)) } return ps @@ -389,6 +400,15 @@ func (d Dialect) replacement(occ *occurrence) string { return fmt.Sprintf("/*SLICE:%s*/?", occ.name) } return fmt.Sprintf("?%d", occ.number) + case StyleAt: + if occ.kind == kindSlice { + return fmt.Sprintf("/*SLICE:%s*/@%s", occ.name, occ.name) + } + // A bare @name is already native; keep the spelling the user wrote. + if strings.HasPrefix(occ.ident, "@") { + return occ.ident + } + return "@" + occ.name default: if occ.kind == kindSlice { return fmt.Sprintf("/*SLICE:%s*/?", occ.name) diff --git a/internal/sql/preprocess/scan.go b/internal/sql/preprocess/scan.go index b2b4b1f534..a6245e5704 100644 --- a/internal/sql/preprocess/scan.go +++ b/internal/sql/preprocess/scan.go @@ -33,7 +33,8 @@ func (l *lexer) scan(start, end int) []occurrence { } i = j - case c == '@' && l.d.AtSign && isIdentStart(l.at(i+1)): + // @@name is a system function, such as SQL Server's @@ROWCOUNT. + case c == '@' && l.d.AtSign && isIdentStart(l.at(i+1)) && l.at(i-1) != '@': j := l.identEnd(i + 1) out = append(out, occurrence{ kind: kindArg, diff --git a/internal/sql/preprocess/testdata/mssql/arg/input.sql b/internal/sql/preprocess/testdata/mssql/arg/input.sql new file mode 100644 index 0000000000..c689beee0c --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = sqlc.arg(x) AND b = sqlc.narg(y); diff --git a/internal/sql/preprocess/testdata/mssql/arg/output.sql b/internal/sql/preprocess/testdata/mssql/arg/output.sql new file mode 100644 index 0000000000..9dd09b1637 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @x AND b = @y; diff --git a/internal/sql/preprocess/testdata/mssql/arg/side_table.json b/internal/sql/preprocess/testdata/mssql/arg/side_table.json new file mode 100644 index 0000000000..a67d864ad8 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 45, + "dollar": true, + "params": [ + { + "number": 1, + "location": 31, + "origin": 31, + "name": "x", + "named": true + }, + { + "number": 2, + "location": 42, + "origin": 51, + "name": "y", + "named": true, + "nullable": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql new file mode 100644 index 0000000000..f67f702a35 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @Name AND b = sqlc.arg(name) AND c = @NAME; diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql new file mode 100644 index 0000000000..145c90ded9 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @Name AND b = @Name AND c = @NAME; diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json new file mode 100644 index 0000000000..438b1d69e2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json @@ -0,0 +1,30 @@ +[ + { + "start": 0, + "end": 65, + "dollar": true, + "params": [ + { + "number": 1, + "location": 31, + "origin": 31, + "name": "Name", + "named": true + }, + { + "number": 1, + "location": 45, + "origin": 45, + "name": "Name", + "named": true + }, + { + "number": 1, + "location": 59, + "origin": 68, + "name": "Name", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/embed/input.sql b/internal/sql/preprocess/testdata/mssql/embed/input.sql new file mode 100644 index 0000000000..34ec985f7f --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/input.sql @@ -0,0 +1 @@ +SELECT sqlc.embed(users) FROM users WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed/output.sql b/internal/sql/preprocess/testdata/mssql/embed/output.sql new file mode 100644 index 0000000000..7493847494 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/output.sql @@ -0,0 +1 @@ +SELECT users.* FROM users WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed/side_table.json b/internal/sql/preprocess/testdata/mssql/embed/side_table.json new file mode 100644 index 0000000000..fdd0a53517 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 41, + "dollar": true, + "params": [ + { + "number": 1, + "location": 37, + "origin": 47, + "name": "id", + "named": true + } + ], + "embeds": [ + { + "table": "users", + "location": 7, + "origin": 7, + "orig": "sqlc.embed(users)" + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql new file mode 100644 index 0000000000..cd8a15e7bf --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql @@ -0,0 +1 @@ +SELECT id FROM users /* outer /* sqlc.arg(a) */ @b */ WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql new file mode 100644 index 0000000000..cd8a15e7bf --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql @@ -0,0 +1 @@ +SELECT id FROM users /* outer /* sqlc.arg(a) */ @b */ WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json new file mode 100644 index 0000000000..94445664da --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json @@ -0,0 +1,16 @@ +[ + { + "start": 0, + "end": 69, + "dollar": true, + "params": [ + { + "number": 1, + "location": 65, + "origin": 65, + "name": "id", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/slice/input.sql b/internal/sql/preprocess/testdata/mssql/slice/input.sql new file mode 100644 index 0000000000..6a76a052a4 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id IN (sqlc.slice(ids)) AND name = @name; diff --git a/internal/sql/preprocess/testdata/mssql/slice/output.sql b/internal/sql/preprocess/testdata/mssql/slice/output.sql new file mode 100644 index 0000000000..2816aaef80 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id IN (/*SLICE:ids*/@ids) AND name = @name; diff --git a/internal/sql/preprocess/testdata/mssql/slice/side_table.json b/internal/sql/preprocess/testdata/mssql/slice/side_table.json new file mode 100644 index 0000000000..32867f1747 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 70, + "dollar": true, + "params": [ + { + "number": 1, + "location": 47, + "origin": 34, + "name": "ids", + "named": true, + "slice": true + }, + { + "number": 2, + "location": 64, + "origin": 62, + "name": "name", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql new file mode 100644 index 0000000000..89714db7ab --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql @@ -0,0 +1 @@ +UPDATE users SET name = @name WHERE id = @id; SELECT @@ROWCOUNT; diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql new file mode 100644 index 0000000000..89714db7ab --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql @@ -0,0 +1 @@ +UPDATE users SET name = @name WHERE id = @id; SELECT @@ROWCOUNT; diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json new file mode 100644 index 0000000000..ad18705e8f --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json @@ -0,0 +1,28 @@ +[ + { + "start": 0, + "end": 45, + "dollar": true, + "params": [ + { + "number": 1, + "location": 24, + "origin": 24, + "name": "name", + "named": true + }, + { + "number": 2, + "location": 41, + "origin": 41, + "name": "id", + "named": true + } + ] + }, + { + "start": 45, + "end": 64, + "dollar": true + } +] From 8ba78242d115d4ccd4541012f248f0cdfd5e5fa5 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:48:11 -0800 Subject: [PATCH 09/74] mssql: support sqlc.embed The core analyzer path expanded a rewritten sqlc.embed(t) star into the table's columns but never folded them back into one embedded column, so SQL Server queries got flat rows instead of the table's struct. Fold each embed star's columns into a column naming its source table, which also resolves an embed of an alias to the table behind it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/parse_core.go | 40 +++++++++++++++++ .../mssql_sqlc_macros/mssql/go/query.sql.go | 44 +++++++++++++++++++ .../mssql_sqlc_macros/mssql/query.sql | 6 +++ 3 files changed, 90 insertions(+) diff --git a/internal/compiler/parse_core.go b/internal/compiler/parse_core.go index 2e1dfc7042..49840002cc 100644 --- a/internal/compiler/parse_core.go +++ b/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) placeholders, err := placeholderNames(raw) if err != nil { return nil, err @@ -105,6 +106,45 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess. }, nil } +// embedColumns folds the columns each sqlc.embed() star expanded to into +// the one column codegen embeds the table's struct for. The table is the +// columns' source, so an embed of an alias names the table behind it. +func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, embeds preprocess.EmbedSet) []*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 && cols[i].Table != nil { + out = append(out, &Column{Name: embed.Table.Name, EmbedTable: cols[i].Table}) + } else { + out = append(out, cols[i:i+n]...) + } + i += n + } + return out +} + func coreColumn(c core.Column) *Column { col := &Column{ Name: c.Name, diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go index 6ca10472c2..b93d8cbec6 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go @@ -12,6 +12,50 @@ import ( "strings" ) +const authorBooks = `-- name: AuthorBooks :many +SELECT a.id, a.name, a.bio, books.id, books.author_id, books.title, books.title AS book_title +FROM authors a JOIN books ON books.author_id = a.id +WHERE a.id = @author_id +ORDER BY books.id; +` + +type AuthorBooksRow struct { + Author Author + Book Book + BookTitle string +} + +func (q *Queries) AuthorBooks(ctx context.Context, authorID int64) ([]AuthorBooksRow, error) { + rows, err := q.db.QueryContext(ctx, authorBooks, sql.Named("author_id", authorID)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []AuthorBooksRow + for rows.Next() { + var i AuthorBooksRow + if err := rows.Scan( + &i.Author.ID, + &i.Author.Name, + &i.Author.Bio, + &i.Book.ID, + &i.Book.AuthorID, + &i.Book.Title, + &i.BookTitle, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const createAuthor = `-- name: CreateAuthor :exec INSERT INTO authors (id, name, bio) VALUES (@id, @name, @bio); ` diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql index 5de1c42a5d..be9e4fc7a2 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql @@ -12,3 +12,9 @@ SELECT id, name FROM authors WHERE name <> @name AND id IN (sqlc.slice(ids)) AND -- name: RowCount :one SELECT CAST(@@ROWCOUNT AS INT) AS row_count; + +-- name: AuthorBooks :many +SELECT sqlc.embed(a), sqlc.embed(books), books.title AS book_title +FROM authors a JOIN books ON books.author_id = a.id +WHERE a.id = sqlc.arg(author_id) +ORDER BY books.id; From bdee10dd0cad2b0972f1c804ad7deb9b08620167 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:51:51 -0800 Subject: [PATCH 10/74] core: let set operation branches see the enclosing query A subquery's analyzer took the scope of the query it is nested in as its outer scope. A set operation binds no scope of its own, so the branches of a UNION nested in another query got none, and a correlated reference in them, as in CROSS APPLY (SELECT ... WHERE x = a.id UNION ALL ...), failed as an unknown column. They now see the scope the set operation itself sees. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 8 +++++- .../mssql_correlated_union/mssql/exec.json | 5 ++++ .../mssql_correlated_union/mssql/query.sql | 8 ++++++ .../mssql_correlated_union/mssql/schema.sql | 10 +++++++ .../mssql_correlated_union/mssql/stdout.json | 28 +++++++++++++++++++ 5 files changed, 58 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 70fa3c81bc..52c56c9520 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -83,10 +83,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 binds no scope of its own, so its branches see the + // query it is nested in. + outer := a.scope + if outer == nil { + outer = a.outer + } sub := &analyzer{ cat: a.cat, params: a.params, - outer: a.scope, + outer: outer, ctes: a.ctes, stars: a.stars, } diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json b/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql b/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql new file mode 100644 index 0000000000..b5dd9a8bca --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: Related :many +SELECT a.id, r.title +FROM authors a +CROSS APPLY ( + SELECT title FROM books WHERE author_id = a.id + UNION ALL + SELECT name FROM authors WHERE id = a.id +) r; diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql b/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json new file mode 100644 index 0000000000..e5228f14f0 --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json @@ -0,0 +1,28 @@ +[ + { + "name": "Related", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [] + } +] From 8312412a11c8b056e40aec780734f70d042e7e65 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:51:51 -0800 Subject: [PATCH 11/74] mssql: support VALUES as a derived table (VALUES ...) AS v(a, b) in FROM reached the analyzer unconverted. It is now the subquery it stands for, each row a SELECT combined with UNION ALL, and its columns are named by the alias list. A VALUES table can be joined, applied, and refer to the relations before it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_values_table/mssql/exec.json | 5 ++ .../analyze_values_table/mssql/query.sql | 16 +++++ .../analyze_values_table/mssql/schema.sql | 7 ++ .../analyze_values_table/mssql/stdout.json | 68 +++++++++++++++++++ internal/engine/mssql/convert.go | 35 ++++++++++ 5 files changed, 131 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_values_table/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_values_table/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_values_table/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_values_table/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/exec.json b/internal/endtoend/testdata/analyze_values_table/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/query.sql b/internal/endtoend/testdata/analyze_values_table/mssql/query.sql new file mode 100644 index 0000000000..a2224287b0 --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/query.sql @@ -0,0 +1,16 @@ +-- name: Weights :many +SELECT a.id, a.name, v.weight +FROM authors a +JOIN (VALUES (1, 10), (2, 20)) AS v(id, weight) ON v.id = a.id; + +-- name: Correlated :many +SELECT a.id, v.n +FROM authors a +CROSS APPLY (VALUES (1), (2)) v(n) +WHERE v.n < a.id; + +-- name: Lateral :many +SELECT a.id +FROM authors a +CROSS APPLY (VALUES (a.id), (a.id + 1)) v(n) +WHERE v.n > 1; diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql b/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json b/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json new file mode 100644 index 0000000000..ed0b4e767a --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json @@ -0,0 +1,68 @@ +[ + { + "name": "Weights", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "weight", + "type": { + "name": "int" + } + } + ], + "params": [] + }, + { + "name": "Correlated", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "n", + "type": { + "name": "int" + } + } + ], + "params": [] + }, + { + "name": "Lateral", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 7b82d37a20..ed29a5b99b 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -324,6 +324,8 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { sub.Alias = &ast.Alias{Aliasname: &alias} } return sub + case *tsql.InlineDerivedTable: + return c.convertInlineDerivedTable(t) case *tsql.QualifiedJoin: join := &ast.JoinExpr{ Larg: c.convertTableReference(t.FirstTableReference), @@ -369,6 +371,39 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { } } +// convertInlineDerivedTable converts (VALUES ...) AS v(a, b) to the +// subquery it stands for, its rows selected one after another with UNION +// ALL, so the relation's columns are typed from its first row. +func (c *cc) convertInlineDerivedTable(n *tsql.InlineDerivedTable) ast.Node { + var query *ast.SelectStmt + for _, row := range n.RowValues { + sel := &ast.SelectStmt{TargetList: &ast.List{}} + for _, val := range row.ColumnValues { + sel.TargetList.Items = append(sel.TargetList.Items, &ast.ResTarget{ + Val: c.convertScalarExpression(val), + Location: c.loc(val), + }) + } + if query == nil { + query = sel + continue + } + query = &ast.SelectStmt{Op: ast.Union, All: true, Larg: query, Rarg: sel} + } + if query == nil { + return todo(n) + } + sub := &ast.RangeSubselect{Subquery: query} + if n.Alias != nil { + alias := identifierValue(n.Alias) + sub.Alias = &ast.Alias{Aliasname: &alias, Colnames: &ast.List{}} + for _, col := range n.Columns { + sub.Alias.Colnames.Items = append(sub.Alias.Colnames.Items, NewIdentifier(col.Value)) + } + } + return sub +} + // rangeFunction is a call in FROM to a function returning rows of the // columns defs declares. func (c *cc) rangeFunction(n tsql.Node, name string, args []tsql.ScalarExpression, alias *tsql.Identifier, defs []ast.Node) *ast.RangeFunction { From ea9df4d01c66153cb7dcbf8cb7d0998cbb2bb2d4 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:47:49 -0800 Subject: [PATCH 12/74] mssql: seed common built-in functions Window, string, math, date and JSON functions such as ROW_NUMBER, LAG, ISNULL, REPLACE, ROUND, EOMONTH and JSON_VALUE were unknown to the analyzer and came out untyped. Seed them with the result types and nullability SQL Server reports for them, so queries using them get real column types. DATEADD, DATEDIFF, DATEPART and DATENAME are now typed, so the analyze_datepart case is regenerated, its placeholder moved to WHERE where SQL Server can describe the query to check it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_datepart/mssql/query.sql | 4 +- .../analyze_datepart/mssql/stdout.json | 39 +- .../analyze_mssql_functions/mssql/exec.json | 5 + .../analyze_mssql_functions/mssql/query.sql | 71 +++ .../analyze_mssql_functions/mssql/schema.sql | 17 + .../analyze_mssql_functions/mssql/stdout.json | 495 ++++++++++++++++++ internal/engine/mssql/dialect/functions.jsonl | 172 ++++++ 7 files changed, 796 insertions(+), 7 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql index fe22c15579..0c79e36fa1 100644 --- a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql @@ -1,8 +1,8 @@ -- name: Recent :many SELECT id, - DATEADD(day, @days, created) AS due, + DATEADD(day, 1, created) AS due, DATEDIFF(minute, created, SYSUTCDATETIME()) AS age, DATEPART(month, created) AS month_of, DATENAME(weekday, created) AS weekday_of FROM authors -WHERE created > DATEADD(hour, -1, SYSUTCDATETIME()); +WHERE created > DATEADD(day, @days, SYSUTCDATETIME()); diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json index eadcde7994..aa394695d9 100644 --- a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json @@ -11,23 +11,52 @@ "table": "authors" }, { - "name": "due" + "name": "due", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } }, { - "name": "age" + "name": "age", + "type": { + "name": "int", + "nullable": true + } }, { - "name": "month_of" + "name": "month_of", + "type": { + "name": "int", + "nullable": true + } }, { - "name": "weekday_of" + "name": "weekday_of", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } } ], "params": [ { "number": 1, "column": { - "name": "days" + "name": "days", + "type": { + "name": "int" + } } } ] diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql new file mode 100644 index 0000000000..e8468281a8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql @@ -0,0 +1,71 @@ +-- name: Ranking :many +SELECT + id, + LAG(price) OVER (ORDER BY id) AS previous_price, + LEAD(title, 1, 'none') OVER (ORDER BY id) AS next_title, + FIRST_VALUE(subtitle) OVER (ORDER BY id) AS first_subtitle, + LAST_VALUE(qty) OVER (ORDER BY id) AS last_qty +FROM books; + +-- name: Nulls :many +SELECT + ISNULL(rating, 0) AS rating, + ISNULL(discount, 0) AS discount, + NULLIF(qty, 0) AS qty, + CHOOSE(1, title, subtitle) AS chosen, + GREATEST(price, discount) AS greatest_price, + LEAST(title, subtitle) AS least_title +FROM books; + +-- name: Strings :many +SELECT + REPLACE(title, 'a', 'b') AS replaced, + REPLACE(note, 'a', 'b') AS replaced_n, + REVERSE(title) AS reversed, + CHARINDEX('a', title) AS position, + PATINDEX('%a%', note) AS pattern_position, + FORMAT(price, 'N2') AS formatted, + QUOTENAME(name) AS quoted, + STR(weight, 10, 2) AS str_weight +FROM books; + +-- name: Aggregates :one +SELECT + STRING_AGG(title, ',') AS titles, + STRING_AGG(note, ',') AS notes, + STDEV(qty) AS qty_stdev +FROM books; + +-- name: Math :many +SELECT + ABS(qty) AS abs_qty, + ABS(price) AS abs_price, + ABS(cost) AS abs_cost, + CEILING(weight) AS ceiling_weight, + FLOOR(rating) AS floor_rating, + ROUND(discount, 1) AS rounded, + POWER(weight, 2) AS squared, + SQRT(qty) AS root, + SIGN(discount) AS sign_discount +FROM books; + +-- name: Dates :many +SELECT + YEAR(published) AS year, + MONTH(updated) AS month, + DAY(published) AS day, + EOMONTH(published) AS month_end, + DATEFROMPARTS(rating, 1, 1) AS start_date, + DATETIME2FROMPARTS(rating, 1, 1, 0, 0, 0, 0, 3) AS start_time, + SWITCHOFFSET(offset_at, '+01:00') AS switched +FROM books; + +-- name: Json :many +SELECT + ISJSON(doc) AS is_json, + JSON_VALUE(doc, '$.a') AS json_value, + JSON_QUERY(doc, '$.a') AS json_query, + JSON_MODIFY(doc, '$.a', 1) AS json_modified, + HASHBYTES('SHA2_256', title) AS hash, + CHECKSUM(title) AS checksum +FROM books; diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql new file mode 100644 index 0000000000..c41fbe240e --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql @@ -0,0 +1,17 @@ +CREATE TABLE books ( + id INT IDENTITY(1,1) PRIMARY KEY, + title VARCHAR(100) NOT NULL, + subtitle VARCHAR(100), + name NVARCHAR(100) NOT NULL, + note NVARCHAR(200), + price DECIMAL(10,2) NOT NULL, + discount DECIMAL(5,2), + qty INT NOT NULL, + rating INT, + weight FLOAT, + cost MONEY, + published DATE, + updated DATETIME2(3), + offset_at DATETIMEOFFSET, + doc NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json new file mode 100644 index 0000000000..3983024aad --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json @@ -0,0 +1,495 @@ +[ + { + "name": "Ranking", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "books" + }, + { + "name": "previous_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "next_title", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "first_subtitle", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "last_qty", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Nulls", + "cmd": ":many", + "columns": [ + { + "name": "rating", + "type": { + "name": "int" + } + }, + { + "name": "discount", + "type": { + "name": "decimal", + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "chosen", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "greatest_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "least_title", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Strings", + "cmd": ":many", + "columns": [ + { + "name": "replaced", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "replaced_n", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "reversed", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "position", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "pattern_position", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "formatted", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "quoted", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 258 + } + ] + } + }, + { + "name": "str_weight", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Aggregates", + "cmd": ":one", + "columns": [ + { + "name": "titles", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "notes", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "qty_stdev", + "type": { + "name": "float", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Math", + "cmd": ":many", + "columns": [ + { + "name": "abs_qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "abs_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "abs_cost", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "ceiling_weight", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "floor_rating", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "rounded", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "squared", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "root", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "sign_discount", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Dates", + "cmd": ":many", + "columns": [ + { + "name": "year", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "month", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "day", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "month_end", + "type": { + "name": "date", + "nullable": true + } + }, + { + "name": "start_date", + "type": { + "name": "date", + "nullable": true + } + }, + { + "name": "start_time", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + }, + { + "name": "switched", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Json", + "cmd": ":many", + "columns": [ + { + "name": "is_json", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "json_value", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "json_query", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "json_modified", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "hash", + "type": { + "name": "varbinary", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "checksum", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 3469b905ac..c6df25c2fc 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -50,6 +50,28 @@ {"name": "max", "kind": "a", "args": [{"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} {"name": "max", "kind": "a", "args": [{"type": "char"}], "returns": "char", "nullable": true} {"name": "max", "kind": "a", "args": [{"type": "nchar"}], "returns": "nchar", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "varchar(8000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "char"}, {"type": "varchar"}], "returns": "varchar(8000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "nvarchar"}, {"type": "varchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "nchar"}, {"type": "varchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "stdev", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "stdevp", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "var", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "varp", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "row_number", "kind": "w", "returns": "bigint"} +{"name": "rank", "kind": "w", "returns": "bigint"} +{"name": "dense_rank", "kind": "w", "returns": "bigint"} +{"name": "ntile", "kind": "w", "args": [{"type": "bigint"}], "returns": "bigint"} +{"name": "percent_rank", "kind": "w", "returns": "float", "nullable": true} +{"name": "cume_dist", "kind": "w", "returns": "float", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}], "returns": "$1", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "first_value", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "last_value", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} {"name": "getdate", "returns": "datetime"} {"name": "getutcdate", "returns": "datetime"} {"name": "sysdatetime", "returns": "datetime2"} @@ -74,6 +96,156 @@ {"name": "rtrim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} {"name": "trim", "args": [{"type": "varchar"}], "returns": "varchar"} {"name": "trim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "isnull", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1"} +{"name": "nullif", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "choose", "args": [{"type": "int"}, {"type": "any"}], "returns": "$2", "nullable": true} +{"name": "greatest", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "least", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "concat", "args": [{"type": "any"}, {"type": "any"}], "returns": "varchar"} +{"name": "concat", "args": [{"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "any"}, {"type": "any"}], "returns": "varchar"} +{"name": "concat_ws", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "substring", "args": [{"type": "varchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "substring", "args": [{"type": "char"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "substring", "args": [{"type": "nvarchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "substring", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "substring", "args": [{"type": "varbinary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} +{"name": "substring", "args": [{"type": "binary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} +{"name": "left", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "left", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "replace", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "replace", "args": [{"type": "char"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "replace", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "replace", "args": [{"type": "nchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "translate", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "translate", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "replicate", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "reverse", "args": [{"type": "varchar"}], "returns": "$1", "nullable": true} +{"name": "reverse", "args": [{"type": "char"}], "returns": "varchar", "nullable": true} +{"name": "reverse", "args": [{"type": "nvarchar"}], "returns": "$1", "nullable": true} +{"name": "reverse", "args": [{"type": "nchar"}], "returns": "nvarchar", "nullable": true} +{"name": "stuff", "args": [{"type": "varchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "varchar", "nullable": true} +{"name": "stuff", "args": [{"type": "char"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "varchar", "nullable": true} +{"name": "stuff", "args": [{"type": "nvarchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "nvarchar", "nullable": true} +{"name": "stuff", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "nvarchar", "nullable": true} +{"name": "space", "args": [{"type": "int"}], "returns": "varchar(8000)", "nullable": true} +{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}, {"type": "bigint"}], "returns": "int", "nullable": true} +{"name": "patindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "ascii", "args": [{"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "unicode", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "format", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "format", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "quotename", "args": [{"type": "nvarchar"}], "returns": "nvarchar(258)", "nullable": true} +{"name": "quotename", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar(258)", "nullable": true} +{"name": "str", "args": [{"type": "float"}], "returns": "varchar(10)", "nullable": true} +{"name": "str", "args": [{"type": "float"}, {"type": "int"}], "returns": "varchar($2)", "nullable": true} +{"name": "str", "args": [{"type": "float"}, {"type": "int"}, {"type": "int"}], "returns": "varchar($2)", "nullable": true} +{"name": "abs", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "abs", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "decimal"}], "returns": "$1", "nullable": true} +{"name": "abs", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "abs", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "abs", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "abs", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "sign", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "sign", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "decimal"}], "returns": "$1", "nullable": true} +{"name": "sign", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "sign", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "sign", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "sign", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "ceiling", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "ceiling", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "decimal"}], "returns": "decimal", "nullable": true} +{"name": "ceiling", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "ceiling", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "ceiling", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "ceiling", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "floor", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "floor", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "decimal"}], "returns": "decimal", "nullable": true} +{"name": "floor", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "floor", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "floor", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "floor", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "bigint"}, {"type": "int"}], "returns": "bigint", "nullable": true} +{"name": "round", "args": [{"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "smallint"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "tinyint"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "decimal"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "round", "args": [{"type": "money"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "smallmoney"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "float"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "real"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "power", "args": [{"type": "bigint"}, {"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "power", "args": [{"type": "int"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "smallint"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "tinyint"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "decimal"}, {"type": "any"}], "returns": "decimal", "nullable": true} +{"name": "power", "args": [{"type": "money"}, {"type": "any"}], "returns": "money", "nullable": true} +{"name": "power", "args": [{"type": "smallmoney"}, {"type": "any"}], "returns": "money", "nullable": true} +{"name": "power", "args": [{"type": "float"}, {"type": "any"}], "returns": "float", "nullable": true} +{"name": "power", "args": [{"type": "real"}, {"type": "any"}], "returns": "float", "nullable": true} +{"name": "sqrt", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "square", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "exp", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "log", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "log", "args": [{"type": "float"}, {"type": "float"}], "returns": "float", "nullable": true} +{"name": "log10", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "pi", "returns": "float"} +{"name": "rand", "returns": "float", "nullable": true} +{"name": "rand", "args": [{"type": "int"}], "returns": "float", "nullable": true} +{"name": "year", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "month", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "day", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "isdate", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "eomonth", "args": [{"type": "any"}], "returns": "date", "nullable": true} +{"name": "eomonth", "args": [{"type": "any"}, {"type": "int"}], "returns": "date", "nullable": true} +{"name": "datefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "date", "nullable": true} +{"name": "datetimefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetime", "nullable": true} +{"name": "datetime2fromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetime2($8)", "nullable": true} +{"name": "datetimeoffsetfromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetimeoffset($10)", "nullable": true} +{"name": "timefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "time($5)", "nullable": true} +{"name": "switchoffset", "args": [{"type": "datetimeoffset"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "todatetimeoffset", "args": [{"type": "any"}, {"type": "any"}], "returns": "datetimeoffset", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "datediff", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "datediff_big", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "datepart", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "datename", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "nvarchar(30)", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "$2", "nullable": true} +{"name": "isjson", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "isjson", "args": [{"type": "any"}, {"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "json_value", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "json_query", "args": [{"type": "any"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_query", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_modify", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_object", "returns": "nvarchar(max)", "nullable": true} +{"name": "json_array", "returns": "nvarchar(max)", "nullable": true} +{"name": "hashbytes", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "varbinary(8000)", "nullable": true} +{"name": "checksum", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "binary_checksum", "args": [{"type": "any"}], "returns": "int", "nullable": true} {"name": "openjson", "args": [{"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} {"name": "openjson", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} {"name": "string_split", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "$1"} From d23c81790896dd724de396a7797816e5c1e60773 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:49:14 -0800 Subject: [PATCH 13/74] mssql: type mixed arithmetic by data type precedence Only same-type arithmetic was seeded, so an expression mixing types such as decimal * int fell back to a cast and came out as bigint. SQL Server gives such an expression the operand type with the higher data type precedence, and + on strings concatenates, giving a Unicode result when either side is Unicode and a variable-length one when either side is. Seed those operator pairs. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_mssql_arithmetic/mssql/exec.json | 5 + .../analyze_mssql_arithmetic/mssql/query.sql | 23 + .../analyze_mssql_arithmetic/mssql/schema.sql | 16 + .../mssql/stdout.json | 128 ++++++ internal/engine/mssql/dialect/operators.jsonl | 432 ++++++++++++++++++ 5 files changed, 604 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json create mode 100644 internal/engine/mssql/dialect/operators.jsonl diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql new file mode 100644 index 0000000000..da4ff4cc83 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql @@ -0,0 +1,23 @@ +-- name: Numeric :many +SELECT + royalties * 2 AS doubled, + royalties / units AS per_unit, + units * weight AS weighted, + ratio + units AS ratio_units, + ratio * weight AS ratio_weight, + units + total AS units_total, + refunds - flags AS net_refunds, + fee * units AS fee_units, + small_fee + units AS small_fee_units, + small_fee + fee AS fees, + units % refunds AS remainder +FROM sales; + +-- name: Concatenation :many +SELECT + code + code AS codes, + code + title AS code_title, + ncode + title AS ncode_title, + title + name AS title_name, + code + ncode AS code_ncode +FROM sales; diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql new file mode 100644 index 0000000000..891366facd --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql @@ -0,0 +1,16 @@ +CREATE TABLE sales ( + id INT IDENTITY(1,1) PRIMARY KEY, + royalties DECIMAL(10,2), + units INT, + refunds SMALLINT, + flags TINYINT, + total BIGINT, + ratio REAL, + weight FLOAT, + fee MONEY, + small_fee SMALLMONEY, + code CHAR(4), + title VARCHAR(50), + ncode NCHAR(4), + name NVARCHAR(50) +); diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json new file mode 100644 index 0000000000..7ed41e25d7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json @@ -0,0 +1,128 @@ +[ + { + "name": "Numeric", + "cmd": ":many", + "columns": [ + { + "name": "doubled", + "type": { + "name": "decimal", + "nullable": true + } + }, + { + "name": "per_unit", + "type": { + "name": "decimal", + "nullable": true + } + }, + { + "name": "weighted", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "ratio_units", + "type": { + "name": "real", + "nullable": true + } + }, + { + "name": "ratio_weight", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "units_total", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "net_refunds", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "fee_units", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "small_fee_units", + "type": { + "name": "smallmoney", + "nullable": true + } + }, + { + "name": "fees", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "remainder", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Concatenation", + "cmd": ":many", + "columns": [ + { + "name": "codes", + "type": { + "name": "char", + "nullable": true + } + }, + { + "name": "code_title", + "type": { + "name": "varchar", + "nullable": true + } + }, + { + "name": "ncode_title", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "title_name", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "code_ncode", + "type": { + "name": "nchar", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/dialect/operators.jsonl b/internal/engine/mssql/dialect/operators.jsonl new file mode 100644 index 0000000000..8d241329af --- /dev/null +++ b/internal/engine/mssql/dialect/operators.jsonl @@ -0,0 +1,432 @@ +{"name": "+", "left": "float", "right": "real", "result": "float"} +{"name": "+", "left": "float", "right": "decimal", "result": "float"} +{"name": "+", "left": "float", "right": "money", "result": "float"} +{"name": "+", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "+", "left": "float", "right": "bigint", "result": "float"} +{"name": "+", "left": "float", "right": "int", "result": "float"} +{"name": "+", "left": "float", "right": "smallint", "result": "float"} +{"name": "+", "left": "float", "right": "tinyint", "result": "float"} +{"name": "+", "left": "float", "right": "bit", "result": "float"} +{"name": "+", "left": "real", "right": "float", "result": "float"} +{"name": "+", "left": "real", "right": "decimal", "result": "real"} +{"name": "+", "left": "real", "right": "money", "result": "real"} +{"name": "+", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "+", "left": "real", "right": "bigint", "result": "real"} +{"name": "+", "left": "real", "right": "int", "result": "real"} +{"name": "+", "left": "real", "right": "smallint", "result": "real"} +{"name": "+", "left": "real", "right": "tinyint", "result": "real"} +{"name": "+", "left": "real", "right": "bit", "result": "real"} +{"name": "+", "left": "decimal", "right": "float", "result": "float"} +{"name": "+", "left": "decimal", "right": "real", "result": "real"} +{"name": "+", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "+", "left": "money", "right": "float", "result": "float"} +{"name": "+", "left": "money", "right": "real", "result": "real"} +{"name": "+", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "+", "left": "money", "right": "bigint", "result": "money"} +{"name": "+", "left": "money", "right": "int", "result": "money"} +{"name": "+", "left": "money", "right": "smallint", "result": "money"} +{"name": "+", "left": "money", "right": "tinyint", "result": "money"} +{"name": "+", "left": "money", "right": "bit", "result": "money"} +{"name": "+", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "+", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "+", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "+", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "+", "left": "bigint", "right": "float", "result": "float"} +{"name": "+", "left": "bigint", "right": "real", "result": "real"} +{"name": "+", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "bigint", "right": "money", "result": "money"} +{"name": "+", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "+", "left": "int", "right": "float", "result": "float"} +{"name": "+", "left": "int", "right": "real", "result": "real"} +{"name": "+", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "int", "right": "money", "result": "money"} +{"name": "+", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "int", "right": "smallint", "result": "int"} +{"name": "+", "left": "int", "right": "tinyint", "result": "int"} +{"name": "+", "left": "int", "right": "bit", "result": "int"} +{"name": "+", "left": "smallint", "right": "float", "result": "float"} +{"name": "+", "left": "smallint", "right": "real", "result": "real"} +{"name": "+", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "smallint", "right": "money", "result": "money"} +{"name": "+", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "smallint", "right": "int", "result": "int"} +{"name": "+", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "+", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "+", "left": "tinyint", "right": "float", "result": "float"} +{"name": "+", "left": "tinyint", "right": "real", "result": "real"} +{"name": "+", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "tinyint", "right": "money", "result": "money"} +{"name": "+", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "tinyint", "right": "int", "result": "int"} +{"name": "+", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "+", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "+", "left": "bit", "right": "float", "result": "float"} +{"name": "+", "left": "bit", "right": "real", "result": "real"} +{"name": "+", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "bit", "right": "money", "result": "money"} +{"name": "+", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "bit", "right": "int", "result": "int"} +{"name": "+", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "+", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "-", "left": "float", "right": "real", "result": "float"} +{"name": "-", "left": "float", "right": "decimal", "result": "float"} +{"name": "-", "left": "float", "right": "money", "result": "float"} +{"name": "-", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "-", "left": "float", "right": "bigint", "result": "float"} +{"name": "-", "left": "float", "right": "int", "result": "float"} +{"name": "-", "left": "float", "right": "smallint", "result": "float"} +{"name": "-", "left": "float", "right": "tinyint", "result": "float"} +{"name": "-", "left": "float", "right": "bit", "result": "float"} +{"name": "-", "left": "real", "right": "float", "result": "float"} +{"name": "-", "left": "real", "right": "decimal", "result": "real"} +{"name": "-", "left": "real", "right": "money", "result": "real"} +{"name": "-", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "-", "left": "real", "right": "bigint", "result": "real"} +{"name": "-", "left": "real", "right": "int", "result": "real"} +{"name": "-", "left": "real", "right": "smallint", "result": "real"} +{"name": "-", "left": "real", "right": "tinyint", "result": "real"} +{"name": "-", "left": "real", "right": "bit", "result": "real"} +{"name": "-", "left": "decimal", "right": "float", "result": "float"} +{"name": "-", "left": "decimal", "right": "real", "result": "real"} +{"name": "-", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "-", "left": "money", "right": "float", "result": "float"} +{"name": "-", "left": "money", "right": "real", "result": "real"} +{"name": "-", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "-", "left": "money", "right": "bigint", "result": "money"} +{"name": "-", "left": "money", "right": "int", "result": "money"} +{"name": "-", "left": "money", "right": "smallint", "result": "money"} +{"name": "-", "left": "money", "right": "tinyint", "result": "money"} +{"name": "-", "left": "money", "right": "bit", "result": "money"} +{"name": "-", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "-", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "-", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "-", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "-", "left": "bigint", "right": "float", "result": "float"} +{"name": "-", "left": "bigint", "right": "real", "result": "real"} +{"name": "-", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "bigint", "right": "money", "result": "money"} +{"name": "-", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "-", "left": "int", "right": "float", "result": "float"} +{"name": "-", "left": "int", "right": "real", "result": "real"} +{"name": "-", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "int", "right": "money", "result": "money"} +{"name": "-", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "int", "right": "smallint", "result": "int"} +{"name": "-", "left": "int", "right": "tinyint", "result": "int"} +{"name": "-", "left": "int", "right": "bit", "result": "int"} +{"name": "-", "left": "smallint", "right": "float", "result": "float"} +{"name": "-", "left": "smallint", "right": "real", "result": "real"} +{"name": "-", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "smallint", "right": "money", "result": "money"} +{"name": "-", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "smallint", "right": "int", "result": "int"} +{"name": "-", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "-", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "-", "left": "tinyint", "right": "float", "result": "float"} +{"name": "-", "left": "tinyint", "right": "real", "result": "real"} +{"name": "-", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "tinyint", "right": "money", "result": "money"} +{"name": "-", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "tinyint", "right": "int", "result": "int"} +{"name": "-", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "-", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "-", "left": "bit", "right": "float", "result": "float"} +{"name": "-", "left": "bit", "right": "real", "result": "real"} +{"name": "-", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "bit", "right": "money", "result": "money"} +{"name": "-", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "bit", "right": "int", "result": "int"} +{"name": "-", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "-", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "*", "left": "float", "right": "real", "result": "float"} +{"name": "*", "left": "float", "right": "decimal", "result": "float"} +{"name": "*", "left": "float", "right": "money", "result": "float"} +{"name": "*", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "*", "left": "float", "right": "bigint", "result": "float"} +{"name": "*", "left": "float", "right": "int", "result": "float"} +{"name": "*", "left": "float", "right": "smallint", "result": "float"} +{"name": "*", "left": "float", "right": "tinyint", "result": "float"} +{"name": "*", "left": "float", "right": "bit", "result": "float"} +{"name": "*", "left": "real", "right": "float", "result": "float"} +{"name": "*", "left": "real", "right": "decimal", "result": "real"} +{"name": "*", "left": "real", "right": "money", "result": "real"} +{"name": "*", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "*", "left": "real", "right": "bigint", "result": "real"} +{"name": "*", "left": "real", "right": "int", "result": "real"} +{"name": "*", "left": "real", "right": "smallint", "result": "real"} +{"name": "*", "left": "real", "right": "tinyint", "result": "real"} +{"name": "*", "left": "real", "right": "bit", "result": "real"} +{"name": "*", "left": "decimal", "right": "float", "result": "float"} +{"name": "*", "left": "decimal", "right": "real", "result": "real"} +{"name": "*", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "*", "left": "money", "right": "float", "result": "float"} +{"name": "*", "left": "money", "right": "real", "result": "real"} +{"name": "*", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "*", "left": "money", "right": "bigint", "result": "money"} +{"name": "*", "left": "money", "right": "int", "result": "money"} +{"name": "*", "left": "money", "right": "smallint", "result": "money"} +{"name": "*", "left": "money", "right": "tinyint", "result": "money"} +{"name": "*", "left": "money", "right": "bit", "result": "money"} +{"name": "*", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "*", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "*", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "*", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "*", "left": "bigint", "right": "float", "result": "float"} +{"name": "*", "left": "bigint", "right": "real", "result": "real"} +{"name": "*", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "bigint", "right": "money", "result": "money"} +{"name": "*", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "*", "left": "int", "right": "float", "result": "float"} +{"name": "*", "left": "int", "right": "real", "result": "real"} +{"name": "*", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "int", "right": "money", "result": "money"} +{"name": "*", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "int", "right": "smallint", "result": "int"} +{"name": "*", "left": "int", "right": "tinyint", "result": "int"} +{"name": "*", "left": "int", "right": "bit", "result": "int"} +{"name": "*", "left": "smallint", "right": "float", "result": "float"} +{"name": "*", "left": "smallint", "right": "real", "result": "real"} +{"name": "*", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "smallint", "right": "money", "result": "money"} +{"name": "*", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "smallint", "right": "int", "result": "int"} +{"name": "*", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "*", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "*", "left": "tinyint", "right": "float", "result": "float"} +{"name": "*", "left": "tinyint", "right": "real", "result": "real"} +{"name": "*", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "tinyint", "right": "money", "result": "money"} +{"name": "*", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "tinyint", "right": "int", "result": "int"} +{"name": "*", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "*", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "*", "left": "bit", "right": "float", "result": "float"} +{"name": "*", "left": "bit", "right": "real", "result": "real"} +{"name": "*", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "bit", "right": "money", "result": "money"} +{"name": "*", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "bit", "right": "int", "result": "int"} +{"name": "*", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "*", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "/", "left": "float", "right": "real", "result": "float"} +{"name": "/", "left": "float", "right": "decimal", "result": "float"} +{"name": "/", "left": "float", "right": "money", "result": "float"} +{"name": "/", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "/", "left": "float", "right": "bigint", "result": "float"} +{"name": "/", "left": "float", "right": "int", "result": "float"} +{"name": "/", "left": "float", "right": "smallint", "result": "float"} +{"name": "/", "left": "float", "right": "tinyint", "result": "float"} +{"name": "/", "left": "float", "right": "bit", "result": "float"} +{"name": "/", "left": "real", "right": "float", "result": "float"} +{"name": "/", "left": "real", "right": "decimal", "result": "real"} +{"name": "/", "left": "real", "right": "money", "result": "real"} +{"name": "/", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "/", "left": "real", "right": "bigint", "result": "real"} +{"name": "/", "left": "real", "right": "int", "result": "real"} +{"name": "/", "left": "real", "right": "smallint", "result": "real"} +{"name": "/", "left": "real", "right": "tinyint", "result": "real"} +{"name": "/", "left": "real", "right": "bit", "result": "real"} +{"name": "/", "left": "decimal", "right": "float", "result": "float"} +{"name": "/", "left": "decimal", "right": "real", "result": "real"} +{"name": "/", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "/", "left": "money", "right": "float", "result": "float"} +{"name": "/", "left": "money", "right": "real", "result": "real"} +{"name": "/", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "/", "left": "money", "right": "bigint", "result": "money"} +{"name": "/", "left": "money", "right": "int", "result": "money"} +{"name": "/", "left": "money", "right": "smallint", "result": "money"} +{"name": "/", "left": "money", "right": "tinyint", "result": "money"} +{"name": "/", "left": "money", "right": "bit", "result": "money"} +{"name": "/", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "/", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "/", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "/", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "/", "left": "bigint", "right": "float", "result": "float"} +{"name": "/", "left": "bigint", "right": "real", "result": "real"} +{"name": "/", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "bigint", "right": "money", "result": "money"} +{"name": "/", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "/", "left": "int", "right": "float", "result": "float"} +{"name": "/", "left": "int", "right": "real", "result": "real"} +{"name": "/", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "int", "right": "money", "result": "money"} +{"name": "/", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "int", "right": "smallint", "result": "int"} +{"name": "/", "left": "int", "right": "tinyint", "result": "int"} +{"name": "/", "left": "int", "right": "bit", "result": "int"} +{"name": "/", "left": "smallint", "right": "float", "result": "float"} +{"name": "/", "left": "smallint", "right": "real", "result": "real"} +{"name": "/", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "smallint", "right": "money", "result": "money"} +{"name": "/", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "smallint", "right": "int", "result": "int"} +{"name": "/", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "/", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "/", "left": "tinyint", "right": "float", "result": "float"} +{"name": "/", "left": "tinyint", "right": "real", "result": "real"} +{"name": "/", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "tinyint", "right": "money", "result": "money"} +{"name": "/", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "tinyint", "right": "int", "result": "int"} +{"name": "/", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "/", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "/", "left": "bit", "right": "float", "result": "float"} +{"name": "/", "left": "bit", "right": "real", "result": "real"} +{"name": "/", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "bit", "right": "money", "result": "money"} +{"name": "/", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "bit", "right": "int", "result": "int"} +{"name": "/", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "/", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "%", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "%", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "%", "left": "money", "right": "bigint", "result": "money"} +{"name": "%", "left": "money", "right": "int", "result": "money"} +{"name": "%", "left": "money", "right": "smallint", "result": "money"} +{"name": "%", "left": "money", "right": "tinyint", "result": "money"} +{"name": "%", "left": "money", "right": "bit", "result": "money"} +{"name": "%", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "%", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "%", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "bigint", "right": "money", "result": "money"} +{"name": "%", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "%", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "int", "right": "money", "result": "money"} +{"name": "%", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "int", "right": "smallint", "result": "int"} +{"name": "%", "left": "int", "right": "tinyint", "result": "int"} +{"name": "%", "left": "int", "right": "bit", "result": "int"} +{"name": "%", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "smallint", "right": "money", "result": "money"} +{"name": "%", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "smallint", "right": "int", "result": "int"} +{"name": "%", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "%", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "%", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "tinyint", "right": "money", "result": "money"} +{"name": "%", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "tinyint", "right": "int", "result": "int"} +{"name": "%", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "%", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "%", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "bit", "right": "money", "result": "money"} +{"name": "%", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "bit", "right": "int", "result": "int"} +{"name": "%", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "%", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "+", "left": "char", "right": "char", "result": "char"} +{"name": "+", "left": "char", "right": "varchar", "result": "varchar"} +{"name": "+", "left": "char", "right": "nchar", "result": "nchar"} +{"name": "+", "left": "char", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "varchar", "right": "char", "result": "varchar"} +{"name": "+", "left": "varchar", "right": "varchar", "result": "varchar"} +{"name": "+", "left": "varchar", "right": "nchar", "result": "nvarchar"} +{"name": "+", "left": "varchar", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "nchar", "right": "char", "result": "nchar"} +{"name": "+", "left": "nchar", "right": "varchar", "result": "nvarchar"} +{"name": "+", "left": "nchar", "right": "nchar", "result": "nchar"} +{"name": "+", "left": "nchar", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "char", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "varchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "nchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "nvarchar", "result": "nvarchar"} From ae484dfc4e0d3fd9150ee3492384ae963b42bc0a Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:31:44 -0800 Subject: [PATCH 14/74] mssql: resolve INSERTED and DELETED in OUTPUT against the target The converter stripped the INSERTED and DELETED qualifiers from an OUTPUT clause so the columns resolved against the target table. With a FROM clause joining other tables, the bare names were ambiguous, so DELETE b OUTPUT DELETED.id FROM books b JOIN authors a ... failed. And a star lost its qualifier, so OUTPUT INSERTED.* was rewritten into broken SQL: the expansion replaced only the star's first character and named columns without the prefix SQL Server requires. A dialect may now name, in returning_aliases, the pseudo-relations its RETURNING list qualifies the target's columns with. The analyzer reads them as the target while it types that list, and the converter keeps the qualifiers, so INSERTED.* expands to inserted.id, inserted.name, ... Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 4 + internal/core/analyzer/dml.go | 17 ++- internal/core/analyzer/expr.go | 3 + internal/core/analyzer/projection.go | 3 + internal/core/dialect.go | 18 +++ internal/core/seed/seed.go | 10 ++ .../mssql_output_clause/mssql/exec.json | 1 + .../mssql_output_clause/mssql/go/db.go | 31 +++++ .../mssql_output_clause/mssql/go/models.go | 22 ++++ .../mssql_output_clause/mssql/go/query.sql.go | 123 ++++++++++++++++++ .../mssql_output_clause/mssql/query.sql | 16 +++ .../mssql_output_clause/mssql/schema.sql | 2 + .../mssql_output_clause/mssql/sqlc.yaml | 10 ++ internal/engine/mssql/convert.go | 24 +--- internal/engine/mssql/dialect/dialect.json | 1 + 15 files changed, 261 insertions(+), 24 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 52c56c9520..356d7c9eea 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -66,6 +66,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. diff --git a/internal/core/analyzer/dml.go b/internal/core/analyzer/dml.go index 597723cedd..8b7554b638 100644 --- a/internal/core/analyzer/dml.go +++ b/internal/core/analyzer/dml.go @@ -24,7 +24,7 @@ func (a *analyzer) analyzeInsert(s *ast.InsertStmt) error { if err := a.bindInsertValues(s.SelectStmt, rel, targets); err != nil { return err } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, rel) } func (a *analyzer) analyzeUpdate(s *ast.UpdateStmt) error { @@ -57,7 +57,7 @@ func (a *analyzer) analyzeUpdate(s *ast.UpdateStmt) error { return fmt.Errorf("where: %w", err) } } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, target) } func (a *analyzer) analyzeDelete(s *ast.DeleteStmt) error { @@ -75,7 +75,7 @@ func (a *analyzer) analyzeDelete(s *ast.DeleteStmt) error { return fmt.Errorf("where: %w", err) } } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, sc.rels[0]) } // relationScope builds the scope a DML statement operates on: the relations it @@ -177,7 +177,16 @@ func (a *analyzer) bindValue(rel scopeRel, target *core.ClassColumn, v ast.Node) return err } -func (a *analyzer) projectReturning(l *ast.List) error { +func (a *analyzer) projectReturning(l *ast.List, target scopeRel) error { + // A dialect's names for the target, such as SQL Server's INSERTED and + // DELETED, refer to it within the list. + if aliases := a.cat.ReturningAliases(); len(aliases) > 0 { + a.returning = map[string]string{} + for _, name := range aliases { + a.returning[name] = target.alias + } + defer func() { a.returning = nil }() + } for _, item := range listItems(l) { rt, ok := item.(*ast.ResTarget) if !ok { diff --git a/internal/core/analyzer/expr.go b/internal/core/analyzer/expr.go index ec7120b96c..14b23bcfc1 100644 --- a/internal/core/analyzer/expr.go +++ b/internal/core/analyzer/expr.go @@ -160,6 +160,9 @@ func (a *analyzer) typeColumnRef(c *ast.ColumnRef) (exprType, error) { relation = parts[0] column = parts[1] } + if target, ok := a.returning[relation]; ok { + relation = target + } rel, col, ok, err := a.resolveColumn(relation, column) if err != nil { return exprType{}, err diff --git a/internal/core/analyzer/projection.go b/internal/core/analyzer/projection.go index 17fc3cbf47..a4ac3d6be0 100644 --- a/internal/core/analyzer/projection.go +++ b/internal/core/analyzer/projection.go @@ -129,6 +129,9 @@ func (a *analyzer) emitStar(rt *ast.ResTarget, fields []string) { if len(fields) > 1 { relName = fields[0] } + if target, ok := a.returning[relName]; ok { + relName = target + } // The star is reported along with the columns it covers, so the query text // can be rewritten to name them. star := core.StarExpansion{Location: rt.Location, Fields: fields} diff --git a/internal/core/dialect.go b/internal/core/dialect.go index e9723c0fb1..3f8133a825 100644 --- a/internal/core/dialect.go +++ b/internal/core/dialect.go @@ -82,6 +82,10 @@ const FlagQualifyDuplicateColumns = "columns.qualify_duplicates" // fill them with the type's default instead. const FlagOuterJoinNullable = "joins.outer_nullable" +// FlagReturningAliases holds, comma separated, the names a RETURNING list +// may use for the statement's target. +const FlagReturningAliases = "returning.aliases" + // FlagDefaultSchema holds the schema the dialect puts an unqualified object // in, when that is not the catalog's own default: a type in it is reported // without its schema. @@ -211,6 +215,20 @@ func (c *Catalog) OuterJoinsNullable() bool { return v == "true" } +// ReturningAliases lists the names a RETURNING list may qualify a column of +// the statement's target with, as SQL Server's OUTPUT clause reads +// INSERTED.id and DELETED.id. +func (c *Catalog) ReturningAliases() []string { + if c.dialectOID == 0 { + return nil + } + v, _ := c.DialectFlag(c.dialectOID, FlagReturningAliases) + if v == "" { + return nil + } + return strings.Split(v, ",") +} + // DefaultNamespaces lists the namespaces a type is reported from without // qualification: the catalog's default, PostgreSQL's system catalog, and // the dialect's own default schema when it names one. diff --git a/internal/core/seed/seed.go b/internal/core/seed/seed.go index daedab961c..cfbedf69fa 100644 --- a/internal/core/seed/seed.go +++ b/internal/core/seed/seed.go @@ -88,6 +88,11 @@ type Settings struct { // nullable, as SQL Server fills an unmatched row with NULL. OuterJoinNullable bool `json:"outer_join_nullable,omitempty"` + // ReturningAliases are the names a RETURNING list may qualify a column + // of the statement's target with, as SQL Server's OUTPUT clause has + // INSERTED and DELETED. + ReturningAliases []string `json:"returning_aliases,omitempty"` + // Comparison operators are registered as (T, T) -> Bool for every type in // ComparisonCategories. Comparison []string `json:"comparison,omitempty"` @@ -669,6 +674,11 @@ func (b *builder) consts() error { return err } } + if len(b.settings.ReturningAliases) > 0 { + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagReturningAliases, strings.Join(b.settings.ReturningAliases, ",")); err != nil { + return err + } + } // A schema declares types the seed knows nothing about — enums, domains, // arrays, a SQLite column typed whatever the author felt like. Recording // the comparison operators lets the catalog give those types the same ones. diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json b/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go new file mode 100644 index 0000000000..bc401e8242 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go @@ -0,0 +1,22 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int64 + Name string + Bio sql.NullString +} + +type Book struct { + ID int64 + AuthorID int64 + Title string + Price sql.NullString +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go new file mode 100644 index 0000000000..76833127fa --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go @@ -0,0 +1,123 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const createBook = `-- name: CreateBook :one +INSERT INTO books (id, author_id, title) OUTPUT inserted.id, inserted.author_id, inserted.title, inserted.price VALUES (@id, @author_id, @title); +` + +type CreateBookParams struct { + ID int64 + AuthorID int64 + Title string +} + +func (q *Queries) CreateBook(ctx context.Context, arg CreateBookParams) (Book, error) { + row := q.db.QueryRowContext(ctx, createBook, sql.Named("id", arg.ID), sql.Named("author_id", arg.AuthorID), sql.Named("title", arg.Title)) + var i Book + err := row.Scan( + &i.ID, + &i.AuthorID, + &i.Title, + &i.Price, + ) + return i, err +} + +const deleteBook = `-- name: DeleteBook :one +DELETE FROM books OUTPUT deleted.id, deleted.author_id, deleted.title, deleted.price WHERE id = @id; +` + +func (q *Queries) DeleteBook(ctx context.Context, id int64) (Book, error) { + row := q.db.QueryRowContext(ctx, deleteBook, sql.Named("id", id)) + var i Book + err := row.Scan( + &i.ID, + &i.AuthorID, + &i.Title, + &i.Price, + ) + return i, err +} + +const deleteByAuthor = `-- name: DeleteByAuthor :many +DELETE b OUTPUT DELETED.id, DELETED.title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; +` + +type DeleteByAuthorRow struct { + ID int64 + Title string +} + +func (q *Queries) DeleteByAuthor(ctx context.Context, name string) ([]DeleteByAuthorRow, error) { + rows, err := q.db.QueryContext(ctx, deleteByAuthor, sql.Named("name", name)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []DeleteByAuthorRow + for rows.Next() { + var i DeleteByAuthorRow + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const retitleByAuthor = `-- name: RetitleByAuthor :many +UPDATE b SET title = @title +OUTPUT INSERTED.id, DELETED.title AS old_title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; +` + +type RetitleByAuthorParams struct { + Title string + Name string +} + +type RetitleByAuthorRow struct { + ID int64 + OldTitle string +} + +func (q *Queries) RetitleByAuthor(ctx context.Context, arg RetitleByAuthorParams) ([]RetitleByAuthorRow, error) { + rows, err := q.db.QueryContext(ctx, retitleByAuthor, sql.Named("title", arg.Title), sql.Named("name", arg.Name)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []RetitleByAuthorRow + for rows.Next() { + var i RetitleByAuthorRow + if err := rows.Scan(&i.ID, &i.OldTitle); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql b/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql new file mode 100644 index 0000000000..c08f806278 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql @@ -0,0 +1,16 @@ +-- name: CreateBook :one +INSERT INTO books (id, author_id, title) OUTPUT INSERTED.* VALUES (@id, @author_id, @title); + +-- name: RetitleByAuthor :many +UPDATE b SET title = @title +OUTPUT INSERTED.id, DELETED.title AS old_title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; + +-- name: DeleteByAuthor :many +DELETE b OUTPUT DELETED.id, DELETED.title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; + +-- name: DeleteBook :one +DELETE FROM books OUTPUT DELETED.* WHERE id = @id; diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql b/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql new file mode 100644 index 0000000000..28e9d45cf4 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE authors (id BIGINT IDENTITY(1,1) PRIMARY KEY, name NVARCHAR(100) NOT NULL, bio NVARCHAR(MAX)); +CREATE TABLE books (id BIGINT PRIMARY KEY, author_id BIGINT NOT NULL, title NVARCHAR(200) NOT NULL, price DECIMAL(10,2)); diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index ed29a5b99b..bc4e69649c 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -930,36 +930,20 @@ func datepart(n tsql.ScalarExpression) string { } // convertOutputClause converts an OUTPUT clause to a returning list. The -// INSERTED and DELETED pseudo-table qualifiers are stripped so the columns -// resolve against the statement's target table. +// dialect names INSERTED and DELETED as the target's aliases there, so the +// qualifiers are kept, and a star they qualify expands to columns they +// qualify too. func (c *cc) convertOutputClause(n *tsql.OutputClause) *ast.List { if n == nil || len(n.SelectColumns) == 0 { return nil } list := &ast.List{} for _, elem := range n.SelectColumns { - target := c.convertSelectElement(elem) - if res, ok := target.(*ast.ResTarget); ok { - stripOutputQualifier(res.Val) - } - list.Items = append(list.Items, target) + list.Items = append(list.Items, c.convertSelectElement(elem)) } return list } -func stripOutputQualifier(node ast.Node) { - ref, ok := node.(*ast.ColumnRef) - if !ok || ref.Fields == nil || len(ref.Fields.Items) < 2 { - return - } - if first, ok := ref.Fields.Items[0].(*ast.String); ok { - switch first.Str { - case "inserted", "deleted": - ref.Fields.Items = ref.Fields.Items[1:] - } - } -} - func (c *cc) convertInsertStatement(n *tsql.InsertStatement) ast.Node { if n.InsertSpecification == nil { return todo(n) diff --git a/internal/engine/mssql/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 701b03c3c4..1519273f43 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -10,6 +10,7 @@ "bool": "bit", "limit": "bigint", "outer_join_nullable": true, + "returning_aliases": ["inserted", "deleted"], "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="], "comparison_categories": "NBSD", "arithmetic": ["+", "-", "*", "/", "%"], From 0143d2c4e0b0fea9b19083a8296b32a4cddc726a Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:34:03 -0800 Subject: [PATCH 15/74] mssql: type TRY_CAST and TRY_CONVERT as nullable TRY_CAST and TRY_CONVERT yield NULL for a value they cannot convert, but were converted as plain casts, which are NOT NULL over a NOT NULL operand. Their target type is now marked nullable, as SQL Server describes it. A placeholder cast this way is still typed NOT NULL by the cast, as with CAST. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_try_conversions/mssql/exec.json | 5 ++ .../analyze_try_conversions/mssql/query.sql | 7 +++ .../analyze_try_conversions/mssql/schema.sql | 6 ++ .../analyze_try_conversions/mssql/stdout.json | 60 +++++++++++++++++++ internal/engine/mssql/convert.go | 30 ++++++---- 5 files changed, 98 insertions(+), 10 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json b/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql new file mode 100644 index 0000000000..adf4881cde --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql @@ -0,0 +1,7 @@ +-- name: Converted :many +SELECT id, + TRY_CAST(raw AS INT) AS as_int, + TRY_CONVERT(DECIMAL(5,1), raw) AS as_decimal, + TRY_CAST(note AS NVARCHAR(MAX)) AS as_text +FROM readings +WHERE TRY_CAST(@min AS INT) > 0; diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql b/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json new file mode 100644 index 0000000000..6839d20eef --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json @@ -0,0 +1,60 @@ +[ + { + "name": "Converted", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "as_int", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "as_decimal", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "as_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index bc4e69649c..f0a5c4d1fa 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -6,6 +6,7 @@ import ( tsql "github.com/sqlc-dev/teesql/ast" + "github.com/sqlc-dev/sqlc/internal/core" "github.com/sqlc-dev/sqlc/internal/sql/ast" ) @@ -678,11 +679,7 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Location: c.loc(e), } case *tsql.TryCastCall: - return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), - TypeName: dataTypeName(e.DataType), - Location: c.loc(e), - } + return c.tryCast(e.Parameter, e.DataType, e) case *tsql.ConvertCall: return &ast.TypeCast{ Arg: c.convertScalarExpression(e.Parameter), @@ -690,11 +687,7 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Location: c.loc(e), } case *tsql.TryConvertCall: - return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), - TypeName: dataTypeName(e.DataType), - Location: c.loc(e), - } + return c.tryCast(e.Parameter, e.DataType, e) case *tsql.CoalesceExpression: coalesce := &ast.CoalesceExpr{ Args: &ast.List{}, @@ -794,6 +787,23 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { } } +// tryCast converts TRY_CAST and TRY_CONVERT, which yield NULL for a value +// they cannot convert, so their result is nullable whatever the operand is. +// A placeholder cast this way is typed by the cast as it is by CAST. +func (c *cc) tryCast(arg tsql.ScalarExpression, dataType tsql.DataTypeReference, n tsql.Node) ast.Node { + tn := dataTypeName(dataType) + if _, ok := arg.(*tsql.VariableReference); !ok { + if t := core.TypeExprOfTypeName(tn); t != nil { + tn = &ast.TypeName{Spelling: "Nullable(" + t.String() + ")"} + } + } + return &ast.TypeCast{ + Arg: c.convertScalarExpression(arg), + TypeName: tn, + Location: c.loc(n), + } +} + func binaryOperator(binaryExpressionType string) string { switch binaryExpressionType { case "Add": From ac276a8e207e96f0cba2730752399c5076840764 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:35:34 -0800 Subject: [PATCH 16/74] mssql: type PARSE and TRY_PARSE PARSE and TRY_PARSE were left unconverted, so their result was untyped and a placeholder in them was lost. They are now the conversions they are: PARSE as CAST, TRY_PARSE as the nullable TRY_CAST. What they parse is a string, so a placeholder there is the nvarchar(4000) SQL Server takes it as, and a culture placeholder is nvarchar. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_try_conversions/mssql/query.sql | 7 +++ .../analyze_try_conversions/mssql/stdout.json | 56 +++++++++++++++++++ internal/engine/mssql/convert.go | 51 ++++++++++++++--- internal/engine/mssql/dialect/functions.jsonl | 1 + 4 files changed, 108 insertions(+), 7 deletions(-) diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql index adf4881cde..320b95474b 100644 --- a/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql @@ -5,3 +5,10 @@ SELECT id, TRY_CAST(note AS NVARCHAR(MAX)) AS as_text FROM readings WHERE TRY_CAST(@min AS INT) > 0; + +-- name: Parsed :many +SELECT id, + TRY_PARSE(raw AS DECIMAL(10,2)) AS try_parsed, + TRY_PARSE(note AS DATETIME2 USING 'en-US') AS try_parsed_date +FROM readings +WHERE PARSE(@limit AS INT) > 0; diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json index 6839d20eef..7af70da068 100644 --- a/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json @@ -56,5 +56,61 @@ } } ] + }, + { + "name": "Parsed", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "try_parsed", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "try_parsed_date", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "limit", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + } + } + ] } ] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index f0a5c4d1fa..3632b0f85e 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -680,6 +680,10 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { } case *tsql.TryCastCall: return c.tryCast(e.Parameter, e.DataType, e) + case *tsql.ParseCall: + return c.parseCall(e.StringValue, e.Culture, e.DataType, false, e) + case *tsql.TryParseCall: + return c.parseCall(e.StringValue, e.Culture, e.DataType, true, e) case *tsql.ConvertCall: return &ast.TypeCast{ Arg: c.convertScalarExpression(e.Parameter), @@ -791,19 +795,52 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { // they cannot convert, so their result is nullable whatever the operand is. // A placeholder cast this way is typed by the cast as it is by CAST. func (c *cc) tryCast(arg tsql.ScalarExpression, dataType tsql.DataTypeReference, n tsql.Node) ast.Node { - tn := dataTypeName(dataType) - if _, ok := arg.(*tsql.VariableReference); !ok { - if t := core.TypeExprOfTypeName(tn); t != nil { - tn = &ast.TypeName{Spelling: "Nullable(" + t.String() + ")"} - } - } return &ast.TypeCast{ Arg: c.convertScalarExpression(arg), - TypeName: tn, + TypeName: tryTypeName(arg, dataType), Location: c.loc(n), } } +// tryTypeName is the type a TRY_ conversion of arg yields: nullable, unless +// arg is a placeholder, which the conversion types as CAST does. +func tryTypeName(arg tsql.ScalarExpression, dataType tsql.DataTypeReference) *ast.TypeName { + if _, ok := arg.(*tsql.VariableReference); ok { + return dataTypeName(dataType) + } + return nullableTypeName(dataTypeName(dataType)) +} + +func nullableTypeName(tn *ast.TypeName) *ast.TypeName { + if t := core.TypeExprOfTypeName(tn); t != nil { + return &ast.TypeName{Spelling: "Nullable(" + t.String() + ")"} + } + return tn +} + +// parseCall converts PARSE and TRY_PARSE, which convert a string as CAST +// and TRY_CAST do. What they convert is a string, so a placeholder there is +// the nvarchar(4000) SQL Server takes it as. A culture is passed through a +// call, so a placeholder given for it is still a parameter of the query. +func (c *cc) parseCall(value, culture tsql.ScalarExpression, dataType tsql.DataTypeReference, try bool, n tsql.Node) ast.Node { + tn := dataTypeName(dataType) + if try { + tn = nullableTypeName(tn) + } + arg := c.convertScalarExpression(value) + if _, ok := value.(*tsql.VariableReference); ok { + arg = &ast.TypeCast{Arg: arg, TypeName: typeName("nvarchar", 4000), Location: c.loc(value)} + } + if culture != nil { + arg = &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: "parse"}}}, + Args: &ast.List{Items: []ast.Node{arg, c.convertScalarExpression(culture)}}, + Location: c.loc(n), + } + } + return &ast.TypeCast{Arg: arg, TypeName: tn, Location: c.loc(n)} +} + func binaryOperator(binaryExpressionType string) string { switch binaryExpressionType { case "Add": diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index c6df25c2fc..25791f08bb 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -262,3 +262,4 @@ {"name": "at time zone", "args": [{"type": "datetime2"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(7)", "nullable": true} {"name": "at time zone", "args": [{"type": "datetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(3)", "nullable": true} {"name": "at time zone", "args": [{"type": "smalldatetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(0)", "nullable": true} +{"name": "parse", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar"} From e8f1b01c2d7ac00f94e3fb6191a71fcc50a3fcaa Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:36:30 -0800 Subject: [PATCH 17/74] mssql: type @@ROWCOUNT and the other system variables @@ROWCOUNT, @@IDENTITY, @@TRANCOUNT and their relatives were left unconverted, so a column reading one was untyped. Each is now the call of a function seeded under its name, with the type and nullability SQL Server describes it with. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_global_variables/mssql/exec.json | 5 + .../analyze_global_variables/mssql/query.sql | 13 ++ .../analyze_global_variables/mssql/schema.sql | 6 + .../mssql/stdout.json | 123 ++++++++++++++++++ internal/engine/mssql/convert.go | 9 ++ internal/engine/mssql/dialect/functions.jsonl | 19 +++ 6 files changed, 175 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_global_variables/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_global_variables/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json b/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql b/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql new file mode 100644 index 0000000000..d4f08649f4 --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql @@ -0,0 +1,13 @@ +-- name: SessionInfo :one +SELECT @@ROWCOUNT AS row_count, + @@IDENTITY AS last_identity, + @@SPID AS session_id, + @@VERSION AS version, + @@TRANCOUNT AS tran_count, + @@ERROR AS error, + @@SERVERNAME AS server_name, + @@DATEFIRST AS date_first, + @@DBTS AS dbts; + +-- name: TouchInTransaction :exec +UPDATE readings SET note = @note WHERE id = @id AND @@TRANCOUNT > 0; diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql b/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json b/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json new file mode 100644 index 0000000000..3c1996768c --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json @@ -0,0 +1,123 @@ +[ + { + "name": "SessionInfo", + "cmd": ":one", + "columns": [ + { + "name": "row_count", + "type": { + "name": "int" + } + }, + { + "name": "last_identity", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 38 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "session_id", + "type": { + "name": "smallint" + } + }, + { + "name": "version", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 300 + } + ] + } + }, + { + "name": "tran_count", + "type": { + "name": "int" + } + }, + { + "name": "error", + "type": { + "name": "int" + } + }, + { + "name": "server_name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "date_first", + "type": { + "name": "tinyint", + "nullable": true + } + }, + { + "name": "dbts", + "type": { + "name": "varbinary", + "args": [ + { + "int": 8 + } + ] + } + } + ], + "params": [] + }, + { + "name": "TouchInTransaction", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "note", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + }, + "table": "readings" + } + }, + { + "number": 2, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 3632b0f85e..cff2490a4a 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -779,6 +779,15 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { }, Location: c.loc(e), } + case *tsql.GlobalVariableExpression: + // @@ROWCOUNT and its relatives are typed as the functions the + // dialect seeds under their names. + return &ast.FuncCall{ + Funcname: &ast.List{ + Items: []ast.Node{&ast.String{Str: identifier(e.Name)}}, + }, + Location: c.loc(e), + } case *tsql.ParameterlessCall: return &ast.FuncCall{ Funcname: &ast.List{ diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 25791f08bb..3c55f4536e 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -263,3 +263,22 @@ {"name": "at time zone", "args": [{"type": "datetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(3)", "nullable": true} {"name": "at time zone", "args": [{"type": "smalldatetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(0)", "nullable": true} {"name": "parse", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "@@rowcount", "returns": "int"} +{"name": "@@identity", "returns": "numeric(38, 0)", "nullable": true} +{"name": "@@spid", "returns": "smallint"} +{"name": "@@version", "returns": "nvarchar(300)", "nullable": true} +{"name": "@@trancount", "returns": "int"} +{"name": "@@error", "returns": "int"} +{"name": "@@fetch_status", "returns": "int"} +{"name": "@@servername", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@servicename", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@language", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@datefirst", "returns": "tinyint", "nullable": true} +{"name": "@@max_precision", "returns": "tinyint"} +{"name": "@@nestlevel", "returns": "int"} +{"name": "@@procid", "returns": "int"} +{"name": "@@dbts", "returns": "varbinary(8)"} +{"name": "@@lock_timeout", "returns": "int"} +{"name": "@@options", "returns": "int"} +{"name": "@@textsize", "returns": "int"} +{"name": "@@cursor_rows", "returns": "int"} From ee0257168aaf059a266899b7de850c027380e379 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:35:16 -0800 Subject: [PATCH 18/74] mssql: support PIVOT and UNPIVOT in FROM Both reached the analyzer as an unconverted node. Their columns are the source's columns less the rotated ones, plus the ones the rotation makes, which only the analyzer knows, so the converter passes them on in a new RangePivot node that the analyzer binds against its source. A star over a PIVOT expands to columns named after its values, as 2023, so the expansion quotes names that are no regular identifier. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/expand.go | 5 + internal/core/analyzer/scope.go | 68 ++++++ .../testdata/analyze_pivot/mssql/exec.json | 5 + .../testdata/analyze_pivot/mssql/query.sql | 17 ++ .../testdata/analyze_pivot/mssql/schema.sql | 15 ++ .../testdata/analyze_pivot/mssql/stdout.json | 215 ++++++++++++++++++ internal/engine/mssql/convert.go | 66 ++++++ internal/sql/ast/range_pivot.go | 56 +++++ internal/sql/astutils/rewrite.go | 6 + internal/sql/astutils/walk.go | 14 ++ 10 files changed, 467 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_pivot/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_pivot/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_pivot/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_pivot/mssql/stdout.json create mode 100644 internal/sql/ast/range_pivot.go diff --git a/internal/compiler/expand.go b/internal/compiler/expand.go index 8c8a490b6d..990fc8068b 100644 --- a/internal/compiler/expand.go +++ b/internal/compiler/expand.go @@ -66,6 +66,11 @@ 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 } diff --git a/internal/core/analyzer/scope.go b/internal/core/analyzer/scope.go index ada3da93eb..7bc1424280 100644 --- a/internal/core/analyzer/scope.go +++ b/internal/core/analyzer/scope.go @@ -85,6 +85,13 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { } sc.rels = append(sc.rels, rel) return nil + case *ast.RangePivot: + rel, err := a.bindRangePivot(v) + if err != nil { + return err + } + sc.rels = append(sc.rels, rel) + return nil case *ast.List: // Some engines report a comma-separated FROM as a nested list. for _, item := range listItems(v) { @@ -193,6 +200,67 @@ func findFuncCall(l *ast.List) *ast.FuncCall { return nil } +// bindRangePivot binds PIVOT and UNPIVOT. The columns of the source that +// are not rotated pass through, followed by those the rotation makes, typed +// against the source. +func (a *analyzer) bindRangePivot(p *ast.RangePivot) (scopeRel, error) { + src := &scope{} + if err := a.appendFromItem(src, p.Source); err != nil { + return scopeRel{}, err + } + defer a.binding(src)() + rotated := map[string]bool{} + var made []core.ClassColumn + if p.Unpivot { + // The value column has the type the rotated columns share, and is + // nullable when any of them is. + value := core.ClassColumn{Name: p.ValueColumn, NotNull: true} + for i, item := range listItems(p.InList) { + t, err := a.typeExpr(&ast.ColumnRef{Fields: &ast.List{Items: []ast.Node{item}}}) + if err != nil { + return scopeRel{}, err + } + if i == 0 { + value.TypeOID, value.Type = t.typeOID, t.expr + } + value.NotNull = value.NotNull && !t.nullable + rotated[item.(*ast.String).Str] = true + } + name := a.lookupType(core.TypeExprOfTypeName(p.ForType)) + made = []core.ClassColumn{value, {Name: p.ForColumn, TypeOID: name.typeOID, Type: name.expr}} + } else { + // Each value in the list names a column of the aggregate over the + // rows with that value, null when there are none. + t, err := a.typeExpr(p.Aggregate) + if err != nil { + return scopeRel{}, err + } + rotated[p.ForColumn] = true + for _, arg := range listItems(p.Aggregate.Args) { + if cr, ok := arg.(*ast.ColumnRef); ok { + fields := flattenFields(cr.Fields) + rotated[fields[len(fields)-1]] = true + } + } + for _, item := range listItems(p.InList) { + made = append(made, core.ClassColumn{Name: item.(*ast.String).Str, TypeOID: t.typeOID, Type: t.expr}) + } + } + var rel scopeRel + if p.Alias != nil && p.Alias.Aliasname != nil { + rel.alias = *p.Alias.Aliasname + } + for _, r := range src.rels { + for _, c := range r.cols { + if !rotated[c.Name] { + rel.cols = append(rel.cols, c) + } + } + } + rel.cols = append(rel.cols, made...) + return rel, nil +} + // bindRangeSubselect binds a subquery used as a relation in FROM. func (a *analyzer) bindRangeSubselect(rs *ast.RangeSubselect) (scopeRel, error) { sel, ok := rs.Subquery.(*ast.SelectStmt) diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/exec.json b/internal/endtoend/testdata/analyze_pivot/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/query.sql b/internal/endtoend/testdata/analyze_pivot/mssql/query.sql new file mode 100644 index 0000000000..1ab8ee5bc5 --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/query.sql @@ -0,0 +1,17 @@ +-- name: PivotDerived :many +SELECT pv.* FROM (SELECT author_id, year, amount FROM sales WHERE author_id > @min_author) s +PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; + +-- name: PivotTable :many +SELECT * FROM sales PIVOT (COUNT(amount) FOR year IN ([2023], [2024])) AS pv; + +-- name: PivotColumns :many +SELECT pv.author_id, pv.[2023] FROM sales PIVOT (MAX(amount) FOR year IN ([2023])) pv +WHERE pv.id = @id; + +-- name: Unpivot :many +SELECT u.id, u.metric, u.value FROM stats s +UNPIVOT (value FOR metric IN (q1, q2, q3)) u; + +-- name: UnpivotStar :many +SELECT * FROM stats UNPIVOT (value FOR metric IN (q1)) AS u; diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql b/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql new file mode 100644 index 0000000000..a32279545a --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql @@ -0,0 +1,15 @@ +CREATE TABLE sales ( + id INT NOT NULL PRIMARY KEY, + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL, + note NVARCHAR(50) NULL +); + +CREATE TABLE stats ( + id INT NOT NULL PRIMARY KEY, + name VARCHAR(20) NULL, + q1 INT NOT NULL, + q2 INT NULL, + q3 INT NULL +); diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json b/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json new file mode 100644 index 0000000000..9c91bb88c8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json @@ -0,0 +1,215 @@ +[ + { + "name": "PivotDerived", + "cmd": ":many", + "columns": [ + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "2024", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min_author", + "type": { + "name": "int" + }, + "table": "sales" + } + } + ] + }, + { + "name": "PivotTable", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "note", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "2024", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "PivotColumns", + "cmd": ":many", + "columns": [ + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "sales" + } + } + ] + }, + { + "name": "Unpivot", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "stats" + }, + { + "name": "metric", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "value", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "UnpivotStar", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "stats" + }, + { + "name": "name", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + }, + "table": "stats" + }, + { + "name": "q2", + "type": { + "name": "int", + "nullable": true + }, + "table": "stats" + }, + { + "name": "q3", + "type": { + "name": "int", + "nullable": true + }, + "table": "stats" + }, + { + "name": "value", + "type": { + "name": "int" + } + }, + { + "name": "metric", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index cff2490a4a..e21d8c1b59 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -367,11 +367,77 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { return c.convertOpenJson(t) case *tsql.GlobalFunctionTableReference: return c.convertGlobalFunctionTableReference(t) + case *tsql.PivotedTableReference: + return c.convertPivot(t) + case *tsql.UnpivotedTableReference: + return c.convertUnpivot(t) default: return todo(ref) } } +// convertPivot converts PIVOT. Its columns depend on those of its source, +// which only the analyzer knows, so it is passed on rather than rewritten +// as the grouped query it stands for. +func (c *cc) convertPivot(n *tsql.PivotedTableReference) ast.Node { + if n.AggregateFunctionIdentifier == nil || len(n.AggregateFunctionIdentifier.Identifiers) == 0 || n.PivotColumn == nil { + return todo(n) + } + ids := n.AggregateFunctionIdentifier.Identifiers + agg := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: identifierValue(ids[len(ids)-1])}}}, + Args: &ast.List{}, + Location: c.loc(n), + } + for _, col := range n.ValueColumns { + agg.Args.Items = append(agg.Args.Items, c.convertColumnReference(col)) + } + p := &ast.RangePivot{ + Source: c.convertTableReference(n.TableReference), + Aggregate: agg, + ForColumn: columnName(n.PivotColumn), + InList: &ast.List{}, + } + for _, id := range n.InColumns { + p.InList.Items = append(p.InList.Items, NewIdentifier(id.Value)) + } + if n.Alias != nil { + alias := identifierValue(n.Alias) + p.Alias = &ast.Alias{Aliasname: &alias} + } + return p +} + +// convertUnpivot converts UNPIVOT, which, as PIVOT, keeps the columns of +// its source the analyzer knows. +func (c *cc) convertUnpivot(n *tsql.UnpivotedTableReference) ast.Node { + p := &ast.RangePivot{ + Source: c.convertTableReference(n.TableReference), + Unpivot: true, + ValueColumn: identifierValue(n.ValueColumn), + ForColumn: identifierValue(n.PivotColumn), + ForType: typeName("nvarchar", 128), + InList: &ast.List{}, + } + for _, col := range n.InColumns { + p.InList.Items = append(p.InList.Items, &ast.String{Str: columnName(col)}) + } + if n.Alias != nil { + alias := identifierValue(n.Alias) + p.Alias = &ast.Alias{Aliasname: &alias} + } + return p +} + +// columnName is the name a column reference ends in. +func columnName(n *tsql.ColumnReferenceExpression) string { + if n == nil || n.MultiPartIdentifier == nil || len(n.MultiPartIdentifier.Identifiers) == 0 { + return "" + } + ids := n.MultiPartIdentifier.Identifiers + return identifierValue(ids[len(ids)-1]) +} + // convertInlineDerivedTable converts (VALUES ...) AS v(a, b) to the // subquery it stands for, its rows selected one after another with UNION // ALL, so the relation's columns are typed from its first row. diff --git a/internal/sql/ast/range_pivot.go b/internal/sql/ast/range_pivot.go new file mode 100644 index 0000000000..f3d7b7a761 --- /dev/null +++ b/internal/sql/ast/range_pivot.go @@ -0,0 +1,56 @@ +package ast + +import "github.com/sqlc-dev/sqlc/internal/sql/format" + +// RangePivot is a FROM item that rotates the rows of another, as SQL +// Server's PIVOT and UNPIVOT do. PIVOT turns the values of ForColumn named +// in InList into columns of Aggregate; UNPIVOT turns the columns in InList +// into rows of ValueColumn, named in ForColumn of type ForType. +type RangePivot struct { + Tag NodeTag[RangePivot] `json:"tag"` + + Source Node `json:"source,omitempty"` + Unpivot bool `json:"unpivot"` + Aggregate *FuncCall `json:"aggregate,omitempty"` + ValueColumn string `json:"value_column"` + ForColumn string `json:"for_column"` + ForType *TypeName `json:"for_type,omitempty"` + InList *List `json:"in_list,omitempty"` + Alias *Alias `json:"alias,omitempty"` +} + +func (n *RangePivot) Pos() int { + return 0 +} + +func (n *RangePivot) Format(buf *TrackedBuffer, d format.Dialect) { + if n == nil { + return + } + buf.astFormat(n.Source, d) + if n.Unpivot { + buf.WriteString(" UNPIVOT (") + buf.WriteString(d.QuoteIdent(n.ValueColumn)) + } else { + buf.WriteString(" PIVOT (") + buf.astFormat(n.Aggregate, d) + } + buf.WriteString(" FOR ") + buf.WriteString(d.QuoteIdent(n.ForColumn)) + buf.WriteString(" IN (") + if n.InList != nil { + for i, item := range n.InList.Items { + if i > 0 { + buf.WriteString(", ") + } + if s, ok := item.(*String); ok { + buf.WriteString(d.QuoteIdent(s.Str)) + } + } + } + buf.WriteString("))") + if n.Alias != nil { + buf.WriteString(" AS ") + buf.astFormat(n.Alias, d) + } +} diff --git a/internal/sql/astutils/rewrite.go b/internal/sql/astutils/rewrite.go index 25b274a16c..d178de1893 100644 --- a/internal/sql/astutils/rewrite.go +++ b/internal/sql/astutils/rewrite.go @@ -967,6 +967,12 @@ func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast. a.apply(n, "Alias", nil, n.Alias) a.apply(n, "Coldeflist", nil, n.Coldeflist) + case *ast.RangePivot: + a.apply(n, "Source", nil, n.Source) + a.apply(n, "Aggregate", nil, n.Aggregate) + a.apply(n, "InList", nil, n.InList) + a.apply(n, "Alias", nil, n.Alias) + case *ast.RangeSubselect: a.apply(n, "Subquery", nil, n.Subquery) a.apply(n, "Alias", nil, n.Alias) diff --git a/internal/sql/astutils/walk.go b/internal/sql/astutils/walk.go index 6d5e80bdc3..dcd5119df5 100644 --- a/internal/sql/astutils/walk.go +++ b/internal/sql/astutils/walk.go @@ -1615,6 +1615,20 @@ func Walk(f Visitor, node ast.Node) { Walk(f, n.Coldeflist) } + case *ast.RangePivot: + if n.Source != nil { + Walk(f, n.Source) + } + if n.Aggregate != nil { + Walk(f, n.Aggregate) + } + if n.InList != nil { + Walk(f, n.InList) + } + if n.Alias != nil { + Walk(f, n.Alias) + } + case *ast.RangeSubselect: if n.Subquery != nil { Walk(f, n.Subquery) From 7db97f4e69e04ae969c54024a79bc840949eaff3 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:37:53 -0800 Subject: [PATCH 19/74] mssql: quote expanded identifiers with brackets A star expanded into a column named by a reserved word, or by something that is not an identifier at all, such as PIVOT's [2023], was quoted with double quotes, which SQL Server reads as an identifier only while QUOTED_IDENTIFIER is on. SQL Server's own brackets quote it whatever the setting, with a closing bracket doubled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/expand.go | 3 + .../mssql_star_quoting/mssql/exec.json | 1 + .../mssql_star_quoting/mssql/go/db.go | 31 ++++++++ .../mssql_star_quoting/mssql/go/models.go | 21 ++++++ .../mssql_star_quoting/mssql/go/query.sql.go | 71 +++++++++++++++++++ .../mssql_star_quoting/mssql/query.sql | 5 ++ .../mssql_star_quoting/mssql/schema.sql | 11 +++ .../mssql_star_quoting/mssql/sqlc.yaml | 10 +++ 8 files changed, 153 insertions(+) create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml diff --git a/internal/compiler/expand.go b/internal/compiler/expand.go index 990fc8068b..b7e5d12605 100644 --- a/internal/compiler/expand.go +++ b/internal/compiler/expand.go @@ -78,6 +78,9 @@ 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 + "\"" } diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json b/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go new file mode 100644 index 0000000000..a5ecb804af --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go @@ -0,0 +1,21 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Order struct { + ID int32 + Select string + WeirdName sql.NullInt32 +} + +type Sale struct { + AuthorID int32 + Year int32 + Amount int32 +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go new file mode 100644 index 0000000000..f620a15220 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go @@ -0,0 +1,71 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const listOrders = `-- name: ListOrders :many +SELECT o.id, o.[select], o.[weird]]name] FROM [order] o; +` + +func (q *Queries) ListOrders(ctx context.Context) ([]Order, error) { + rows, err := q.db.QueryContext(ctx, listOrders) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Order + for rows.Next() { + var i Order + if err := rows.Scan(&i.ID, &i.Select, &i.WeirdName); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const salesByYear = `-- name: SalesByYear :many +SELECT pv.author_id, pv.[2023], pv.[2024] FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; +` + +type SalesByYearRow struct { + AuthorID int32 + _2023 sql.NullInt32 + _2024 sql.NullInt32 +} + +func (q *Queries) SalesByYear(ctx context.Context) ([]SalesByYearRow, error) { + rows, err := q.db.QueryContext(ctx, salesByYear) + if err != nil { + return nil, err + } + defer rows.Close() + var items []SalesByYearRow + for rows.Next() { + var i SalesByYearRow + if err := rows.Scan(&i.AuthorID, &i._2023, &i._2024); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql new file mode 100644 index 0000000000..dc4f48900c --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: ListOrders :many +SELECT o.* FROM [order] o; + +-- name: SalesByYear :many +SELECT pv.* FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql b/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql new file mode 100644 index 0000000000..67eb0ffc8a --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE [order] ( + id INT PRIMARY KEY, + [select] NVARCHAR(10) NOT NULL, + [weird]]name] INT +); + +CREATE TABLE sales ( + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" From c1ad6dbdee82979c256ad5cd260c79137e9b4930 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:38:47 -0800 Subject: [PATCH 20/74] mssql: type ISNULL as nullable only when both arguments are ISNULL was seeded as a function returning its first argument's type, never NULL, which is wrong when both arguments can be NULL. It is now converted to the COALESCE node it behaves as: the first argument's type, NULL only when every argument is. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_isnull/mssql/exec.json | 5 ++ .../testdata/analyze_isnull/mssql/query.sql | 7 ++ .../testdata/analyze_isnull/mssql/schema.sql | 6 ++ .../testdata/analyze_isnull/mssql/stdout.json | 68 +++++++++++++++++++ internal/engine/mssql/convert.go | 11 +++ internal/engine/mssql/dialect/functions.jsonl | 1 - 6 files changed, 97 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_isnull/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_isnull/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_isnull/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_isnull/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/exec.json b/internal/endtoend/testdata/analyze_isnull/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/query.sql b/internal/endtoend/testdata/analyze_isnull/mssql/query.sql new file mode 100644 index 0000000000..561b7bece7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/query.sql @@ -0,0 +1,7 @@ +-- name: Defaults :many +SELECT id, + ISNULL(note, raw) AS note_or_raw, + ISNULL(note, note) AS still_nullable, + ISNULL(amount, 0) AS amount +FROM readings +WHERE ISNULL(note, raw) = @value; diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql b/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json b/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json new file mode 100644 index 0000000000..60250d2562 --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json @@ -0,0 +1,68 @@ +[ + { + "name": "Defaults", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "note_or_raw", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "still_nullable", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "value", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index e21d8c1b59..c29117eee8 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -737,6 +737,17 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.ParenthesisExpression: return c.convertScalarExpression(e.Expression) case *tsql.FunctionCall: + // ISNULL(a, b) is typed as COALESCE is: the first argument's type, + // NULL only when both are. + if identifierValue(e.FunctionName) == "isnull" && len(e.Parameters) == 2 && e.OverClause == nil { + return &ast.CoalesceExpr{ + Args: &ast.List{Items: []ast.Node{ + c.convertScalarExpression(e.Parameters[0]), + c.convertScalarExpression(e.Parameters[1]), + }}, + Location: c.loc(e), + } + } return c.convertFunctionCall(e) case *tsql.CastCall: return &ast.TypeCast{ diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 3c55f4536e..f57e3a3919 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -96,7 +96,6 @@ {"name": "rtrim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} {"name": "trim", "args": [{"type": "varchar"}], "returns": "varchar"} {"name": "trim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} -{"name": "isnull", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1"} {"name": "nullif", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} {"name": "choose", "args": [{"type": "int"}, {"type": "any"}], "returns": "$2", "nullable": true} {"name": "greatest", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} From 2e61a8c65104086c709e2c8b6b03129917e6b8b7 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:37:48 -0800 Subject: [PATCH 21/74] mssql: type computed columns by their expression A computed column declares no type, so the converter left it with an empty type name and the whole schema failed to load. The converter now carries the expression as a generated-column constraint, and the core types it against the table's other columns, falling back to an untyped column rather than failing. SQL Server describes most computed columns as nullable, even PERSISTED NOT NULL ones, so the converter marks only the expressions it keeps NOT NULL. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/schema/schema.go | 74 ++++- .../analyze_computed_columns/mssql/exec.json | 5 + .../analyze_computed_columns/mssql/query.sql | 10 + .../analyze_computed_columns/mssql/schema.sql | 16 + .../mssql/stdout.json | 278 ++++++++++++++++++ internal/engine/mssql/convert.go | 37 +++ internal/sql/ast/constr_type.go | 5 +- 7 files changed, 421 insertions(+), 4 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_computed_columns/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index e96d8dbe2a..19e9cb68e8 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -160,7 +160,12 @@ func applyCreateTable(cat *core.Catalog, stmt *ast.CreateTableStmt) error { if err != nil { return err } + var generated []int for i, col := range stmt.Cols { + if generatedExpr(col) != nil { + generated = append(generated, i) + continue + } if col == nil || col.TypeName == nil { return fmt.Errorf("column %d on %q: missing type", i+1, stmt.Name.Name) } @@ -181,9 +186,68 @@ func applyCreateTable(cat *core.Catalog, stmt *ast.CreateTableStmt) error { return fmt.Errorf("attr %s.%s: %w", stmt.Name.Name, col.Colname, err) } } + for _, i := range generated { + if err := applyGenerated(cat, classOID, stmt.Name, stmt.Cols[i], i+1); err != nil { + return fmt.Errorf("attr %s.%s: %w", stmt.Name.Name, stmt.Cols[i].Colname, err) + } + } + return nil +} + +// generatedExpr is the expression of a column that declares no type and +// takes its value, and so its type, from an expression over the row, as a +// SQL Server computed column does. +func generatedExpr(col *ast.ColumnDef) ast.Node { + if col == nil || col.TypeName != nil { + return nil + } + for _, item := range listItems(col.Constraints) { + if c, ok := item.(*ast.Constraint); ok && c.Contype == ast.ConstrTypeGenerated { + return c.RawExpr + } + } return nil } +// applyGenerated records a generated column with the type and nullability +// of its expression, typed against the table's other columns. One whose +// expression cannot be typed is left untyped rather than failing the schema. +// An engine that reports most generated columns nullable whatever their +// expression marks NOT NULL the ones that keep their expression's. +func applyGenerated(cat *core.Catalog, classOID int64, table *ast.TableName, col *ast.ColumnDef, num int) error { + sel := &ast.SelectStmt{ + TargetList: &ast.List{Items: []ast.Node{&ast.ResTarget{Val: generatedExpr(col)}}}, + FromClause: &ast.List{Items: []ast.Node{&ast.RangeVar{Schemaname: &table.Schema, Relname: &table.Name}}}, + } + var res core.Column + var typeOID int64 + if r, err := analyzer.Prepare(cat, sel); err == nil && len(r.Columns) == 1 { + res, typeOID = r.Columns[0], r.Columns[0].TypeOID + // An expression's type may carry arguments, as decimal(10,2) does, + // that no column has interned yet. + if typeOID == 0 && res.Type != nil { + t := *res.Type + t.Nullable = false + typeOID, _ = cat.ResolveTypeExpr(&t) + } + } + if typeOID == 0 { + anyOID, err := cat.ResolveTypeName("any") + if err != nil { + return err + } + res, typeOID = core.Column{}, anyOID + } + return cat.CreateAttributeSpec(core.AttributeSpec{ + ClassOID: classOID, + Name: col.Colname, + TypeOID: typeOID, + Num: num, + NotNull: col.IsNotNull && res.NotNull, + DeclType: res.DataType, + }) +} + func applyDropTable(cat *core.Catalog, stmt *ast.DropTableStmt) error { for _, tn := range stmt.Tables { if tn == nil { @@ -232,11 +296,17 @@ func applyAlterTable(cat *core.Catalog, stmt *ast.AlterTableStmt) error { if cmd.Def == nil { continue } - typeOID, err := columnTypeOID(cat, cmd.Def) + num, err := cat.NextAttributeNum(classOID) if err != nil { return err } - num, err := cat.NextAttributeNum(classOID) + if generatedExpr(cmd.Def) != nil { + if err := applyGenerated(cat, classOID, table, cmd.Def, num); err != nil { + return err + } + continue + } + typeOID, err := columnTypeOID(cat, cmd.Def) if err != nil { return err } diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/exec.json b/internal/endtoend/testdata/analyze_computed_columns/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql b/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql new file mode 100644 index 0000000000..a2566b032e --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: GetComputed :one +SELECT total, doubled, doubled_nn, label, full_label, bio_label, cost, c_isnull, extra +FROM authors +WHERE id = @id; + +-- name: ListAuthors :many +SELECT * FROM authors; + +-- name: CreateAuthor :exec +INSERT INTO authors (name, bio, price) VALUES (@name, @bio, @price); diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql new file mode 100644 index 0000000000..e83f8ca705 --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql @@ -0,0 +1,16 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(200) NULL, + price INT NOT NULL, + total AS (id * 2), + doubled AS (price * 2) PERSISTED, + doubled_nn AS (price * 2) PERSISTED NOT NULL, + label AS (name + N'!'), + full_label AS (CONCAT(name, bio)), + bio_label AS (bio + N'?'), + cost AS (CAST(price AS decimal(10,2))), + c_isnull AS (ISNULL(bio, N'none')) +); + +ALTER TABLE authors ADD extra AS (price + 1); diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json new file mode 100644 index 0000000000..140680e737 --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -0,0 +1,278 @@ +[ + { + "name": "GetComputed", + "cmd": ":one", + "columns": [ + { + "name": "total", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled_nn", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "full_label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "authors" + }, + { + "name": "c_isnull", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + }, + { + "name": "extra", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + } + } + ] + }, + { + "name": "ListAuthors", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "bio", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + }, + { + "name": "price", + "type": { + "name": "int" + }, + "table": "authors" + }, + { + "name": "total", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled_nn", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "full_label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "authors" + }, + { + "name": "c_isnull", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + }, + { + "name": "extra", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + } + ], + "params": [] + }, + { + "name": "CreateAuthor", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + }, + { + "number": 2, + "column": { + "name": "bio", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + } + }, + { + "number": 3, + "column": { + "name": "price", + "type": { + "name": "int" + }, + "table": "authors" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index c29117eee8..395c5b5db9 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1358,6 +1358,20 @@ func (c *cc) convertColumnDefinition(n *tsql.ColumnDefinition, tablePrimaryKey m TypeName: dataTypeName(n.DataType), Location: c.loc(n), } + // A computed column has no declared type: it takes its expression's + // type and nullability, which the core works out once the table's + // other columns exist. SQL Server describes it as nullable unless the + // expression is one it knows keeps NOT NULL, even when PERSISTED NOT + // NULL. + if n.ComputedColumnExpression != nil { + colDef.TypeName = nil + colDef.IsNotNull = keepsNotNull(n.ComputedColumnExpression) + colDef.Constraints = &ast.List{Items: []ast.Node{&ast.Constraint{ + Contype: ast.ConstrTypeGenerated, + RawExpr: c.convertScalarExpression(n.ComputedColumnExpression), + }}} + return colDef + } // T-SQL columns are nullable unless declared otherwise, except that a // rowversion column is NOT NULL unless declared nullable, and sysname @@ -1394,6 +1408,29 @@ func (c *cc) convertColumnDefinition(n *tsql.ColumnDefinition, tablePrimaryKey m return colDef } +// keepsNotNull reports whether SQL Server describes an expression as NOT +// NULL when its operands are: a column, a CASE, ISNULL, CONCAT or a string +// concatenation. Arithmetic, casts and most functions may overflow or fail +// to NULL, so it describes those as nullable. +func keepsNotNull(e tsql.ScalarExpression) bool { + switch e := e.(type) { + case *tsql.ParenthesisExpression: + return keepsNotNull(e.Expression) + case *tsql.ColumnReferenceExpression, *tsql.SearchedCaseExpression, *tsql.SimpleCaseExpression, *tsql.StringLiteral: + return true + case *tsql.FunctionCall: + switch identifierValue(e.FunctionName) { + case "isnull", "concat", "concat_ws": + return true + } + case *tsql.BinaryExpression: + _, l := e.FirstExpression.(*tsql.StringLiteral) + _, r := e.SecondExpression.(*tsql.StringLiteral) + return e.BinaryExpressionType == "Add" && (l || r) && keepsNotNull(e.FirstExpression) && keepsNotNull(e.SecondExpression) + } + return false +} + // dataTypeName returns the lowercased base name of a column's declared type, // e.g. "nvarchar" for NVARCHAR(100). Length and precision arguments do not // name distinct types. diff --git a/internal/sql/ast/constr_type.go b/internal/sql/ast/constr_type.go index c058682672..6f052dd81a 100644 --- a/internal/sql/ast/constr_type.go +++ b/internal/sql/ast/constr_type.go @@ -9,6 +9,7 @@ func (n *ConstrType) Pos() int { // The constraint kinds the analysis reads, numbered as PostgreSQL's parser // numbers them, which is what an engine's converter records. const ( - ConstrTypeNull ConstrType = 1 - ConstrTypeNotNull ConstrType = 2 + ConstrTypeNull ConstrType = 1 + ConstrTypeNotNull ConstrType = 2 + ConstrTypeGenerated ConstrType = 5 ) From 11a28e130acf94b8b06013f1627b016c57083f80 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:40:47 -0800 Subject: [PATCH 22/74] mssql: report a named query sqlc cannot analyze A statement the converter does not handle, such as MERGE or EXEC, was skipped, so a query named on one silently went missing from the generated code. Skipping is right for a schema, which holds statements sqlc has no use for, but a statement carrying a query name is now reported as unsupported, at the statement. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../mssql_unsupported_statement/mssql/exec.json | 1 + .../mssql_unsupported_statement/mssql/query.sql | 8 ++++++++ .../mssql/schema.sql | 12 ++++++++++++ .../mssql_unsupported_statement/mssql/sqlc.yaml | 10 ++++++++++ .../mssql/stderr.txt | 2 ++ internal/engine/mssql/parse.go | 17 +++++++++++++++++ 6 files changed, 50 insertions(+) create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql new file mode 100644 index 0000000000..00a92a27ec --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: ListAuthors :many +SELECT id, name FROM authors; + +-- name: UpsertAuthor :exec +MERGE authors AS t +USING (SELECT @id AS id, @name AS name) s ON t.id = s.id +WHEN MATCHED THEN UPDATE SET name = s.name +WHEN NOT MATCHED THEN INSERT (name) VALUES (s.name); diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql new file mode 100644 index 0000000000..00557ccd53 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql @@ -0,0 +1,12 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); + +CREATE PROCEDURE list_authors AS SELECT id, name FROM authors; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt new file mode 100644 index 0000000000..531a736e9f --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:1: Merge statements are not supported diff --git a/internal/engine/mssql/parse.go b/internal/engine/mssql/parse.go index e222708ece..6007003e97 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -3,13 +3,17 @@ package mssql import ( "bytes" "context" + "fmt" "io" + "regexp" + "strings" "unicode/utf8" "github.com/sqlc-dev/teesql/parser" "github.com/sqlc-dev/sqlc/internal/source" "github.com/sqlc-dev/sqlc/internal/sql/ast" + "github.com/sqlc-dev/sqlc/internal/sql/sqlerr" ) func NewParser() *Parser { @@ -47,6 +51,16 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { converter := &cc{toByte: toByte} out := converter.convert(stmt) if _, ok := out.(*ast.TODO); ok { + // A schema holds statements sqlc has no use for, which are + // skipped. A named query sqlc cannot analyze is an error, + // rather than a query missing from the generated code. + if namedQuery.Match(blob[loc:end]) { + kind := strings.TrimSuffix(strings.TrimPrefix(fmt.Sprintf("%T", stmt), "*ast."), "Statement") + return nil, &sqlerr.Error{ + Message: fmt.Sprintf("%s statements are not supported", kind), + Location: start, + } + } loc = end continue } @@ -65,6 +79,9 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { return stmts, nil } +// namedQuery matches the comment that names a query. +var namedQuery = regexp.MustCompile(`(?m)^\s*--\s*name:\s*\S+`) + // byteOffsets returns a function mapping a UTF-16 code-unit offset — how // teesql records source spans, mirroring ScriptDom — to a byte offset in // blob. For ASCII input the two are identical and the identity is returned. From e60c401255ecbbae167ab89aaadb68d9ff56d69d Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:43:29 -0800 Subject: [PATCH 23/74] golang: make a single result column's variable a Go identifier A query returning one column scans it into a variable named after the column, with only $ replaced. A database may name a column anything, as SQL Server names a pivoted column 2023, a FOR JSON result JSON_F52E2B61-18A1-11d1-B105-00805F49916B, and a bracketed alias [total amount], each of which generated code that did not compile. Every character a Go identifier cannot hold is now replaced, and a leading digit prefixed. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/codegen/golang/result.go | 21 +++++++- .../mssql/exec.json | 1 + .../mssql_result_variable_name/mssql/go/db.go | 31 ++++++++++++ .../mssql/go/models.go | 11 +++++ .../mssql/go/query.sql.go | 49 +++++++++++++++++++ .../mssql/query.sql | 5 ++ .../mssql/schema.sql | 5 ++ .../mssql/sqlc.yaml | 10 ++++ 8 files changed, 131 insertions(+), 2 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml diff --git a/internal/codegen/golang/result.go b/internal/codegen/golang/result.go index 82059c54b7..0290e6c89d 100644 --- a/internal/codegen/golang/result.go +++ b/internal/codegen/golang/result.go @@ -5,6 +5,7 @@ import ( "fmt" "sort" "strings" + "unicode" "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" "github.com/sqlc-dev/sqlc/internal/codegen/sdk" @@ -164,6 +165,23 @@ func columnName(c *plugin.Column, pos int) string { return fmt.Sprintf("column_%d", pos+1) } +// goIdent makes a column name a Go identifier for the variable a single +// column is scanned into: a database may name a column anything, as SQL +// Server names a FOR JSON result JSON_F52E2B61-18A1-11d1-B105-00805F49916B +// and a pivoted one 2023. +func goIdent(name string) string { + name = strings.Map(func(r rune) rune { + if r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) { + return r + } + return '_' + }, name) + if name != "" && unicode.IsDigit(rune(name[0])) { + name = "_" + name + } + return name +} + func paramName(p *plugin.Parameter) string { if p.Column.Name != "" { return argName(p.Column.Name) @@ -282,8 +300,7 @@ func buildQueries(req *plugin.GenerateRequest, options *opts.Options, enums []En if len(query.Columns) == 1 && query.Columns[0].EmbedTable == nil { c := query.Columns[0] - name := columnName(c, 0) - name = strings.Replace(name, "$", "_", -1) + name := goIdent(columnName(c, 0)) retName := escape(name) // For :one queries the scan destination lives in the same scope as // the query parameters, so reusing a parameter's name would cause diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json b/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go new file mode 100644 index 0000000000..6ef0b67e36 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go @@ -0,0 +1,11 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Sale struct { + AuthorID int32 + Year int32 + Amount int32 +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go new file mode 100644 index 0000000000..47d0bf7ccc --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go @@ -0,0 +1,49 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const sales2023 = `-- name: Sales2023 :many +SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; +` + +func (q *Queries) Sales2023(ctx context.Context) ([]sql.NullInt32, error) { + rows, err := q.db.QueryContext(ctx, sales2023) + if err != nil { + return nil, err + } + defer rows.Close() + var items []sql.NullInt32 + for rows.Next() { + var _2023 sql.NullInt32 + if err := rows.Scan(&_2023); err != nil { + return nil, err + } + items = append(items, _2023) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const totalForAuthor = `-- name: TotalForAuthor :one +SELECT [total amount] = SUM(amount) FROM sales WHERE author_id = @author_id; +` + +func (q *Queries) TotalForAuthor(ctx context.Context, authorID int32) (sql.NullInt32, error) { + row := q.db.QueryRowContext(ctx, totalForAuthor, sql.Named("author_id", authorID)) + var total_amount sql.NullInt32 + err := row.Scan(&total_amount) + return total_amount, err +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql new file mode 100644 index 0000000000..735d3bcfae --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Sales2023 :many +SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; + +-- name: TotalForAuthor :one +SELECT [total amount] = SUM(amount) FROM sales WHERE author_id = @author_id; diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql b/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql new file mode 100644 index 0000000000..9017ffc1b3 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE sales ( + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" From 783c09469ae577b841004fea1694204799f97b9b Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:44:31 -0800 Subject: [PATCH 24/74] mssql: type FOR JSON and FOR XML results A query ending in FOR JSON or FOR XML returns one document column, but was reported as returning its select list. It is now that column: nvarchar(max) for JSON, ntext for XML, and xml with TYPE, nullable and named as SQL Server names it; as a subquery, FOR XML without TYPE is nvarchar(max). The query itself is kept as a subquery of the column, so its placeholders and stars are still analyzed. A query with no FROM, like that column's, binds no relations, so what is nested in it now sees the enclosing query, as a set operation's branches already did, and a correlated FOR JSON subquery resolves. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 6 +- .../testdata/analyze_for_json/mssql/exec.json | 5 + .../testdata/analyze_for_json/mssql/query.sql | 13 +++ .../analyze_for_json/mssql/schema.sql | 10 ++ .../analyze_for_json/mssql/stdout.json | 107 ++++++++++++++++++ internal/engine/mssql/convert.go | 65 +++++++++++ 6 files changed, 203 insertions(+), 3 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_for_json/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_for_json/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_for_json/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_for_json/mssql/stdout.json diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 356d7c9eea..8f301f32ea 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -87,10 +87,10 @@ 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 binds no scope of its own, so its branches see the - // query it is nested in. + // 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 { + if outer == nil || len(outer.rels) == 0 { outer = a.outer } sub := &analyzer{ diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/exec.json b/internal/endtoend/testdata/analyze_for_json/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/query.sql b/internal/endtoend/testdata/analyze_for_json/mssql/query.sql new file mode 100644 index 0000000000..e1cb5c0698 --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/query.sql @@ -0,0 +1,13 @@ +-- name: AuthorsJSON :many +SELECT id, name FROM authors WHERE id > @min_id FOR JSON PATH; + +-- name: AuthorsXML :many +SELECT id, name FROM authors FOR XML RAW; + +-- name: AuthorsWithBooks :many +SELECT a.id, + (SELECT b.id, b.title FROM books b WHERE b.author_id = a.id FOR JSON PATH) AS books, + (SELECT b.title + N',' FROM books b WHERE b.author_id = a.id FOR XML PATH('')) AS titles, + (SELECT b.id, b.title FROM books b WHERE b.author_id = a.id FOR XML PATH, TYPE) AS books_xml +FROM authors a +WHERE a.name = @name; diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql b/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json b/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json new file mode 100644 index 0000000000..ec333cc25c --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json @@ -0,0 +1,107 @@ +[ + { + "name": "AuthorsJSON", + "cmd": ":many", + "columns": [ + { + "name": "json_f52e2b61-18a1-11d1-b105-00805f49916b", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min_id", + "type": { + "name": "bigint" + }, + "table": "authors" + } + } + ] + }, + { + "name": "AuthorsXML", + "cmd": ":many", + "columns": [ + { + "name": "xml_f52e2b61-18a1-11d1-b105-00805f49916b", + "type": { + "name": "ntext", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "AuthorsWithBooks", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "books", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "titles", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "books_xml", + "type": { + "name": "xml", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 395c5b5db9..8c79af527c 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -98,6 +98,17 @@ func (c *cc) convertSelectStatement(n *tsql.SelectStatement) ast.Node { if !ok { return stmt } + // A query's own FOR JSON or FOR XML result is a column with the name + // SQL Server gives it, and FOR XML is ntext there. + if qs, ok := n.QueryExpression.(*tsql.QuerySpecification); ok { + if tn := forClauseType(qs.ForClause, true); tn != nil { + res := sel.TargetList.Items[0].(*ast.ResTarget) + res.Val.(*ast.TypeCast).TypeName = nullableTypeName(tn) + if name := forClauseColumn(qs.ForClause, tn); name != "" { + res.Name = &name + } + } + } if with := c.convertWithClause(n.WithCtesAndXmlNamespaces); with != nil { sel.WithClause = with } @@ -237,9 +248,63 @@ func (c *cc) convertQuerySpecification(n *tsql.QuerySpecification) *ast.SelectSt stmt.DistinctClause = &ast.List{} } + if tn := forClauseType(n.ForClause, false); tn != nil { + return forClauseResult(stmt, tn, c.loc(n)) + } return stmt } +// forClauseResult is a query with FOR JSON or FOR XML as what it returns: a +// single nullable column of the document its rows make. The query itself is +// kept as a subquery, so its placeholders and stars are still analyzed. +func forClauseResult(query *ast.SelectStmt, tn *ast.TypeName, loc int) *ast.SelectStmt { + return &ast.SelectStmt{TargetList: &ast.List{Items: []ast.Node{&ast.ResTarget{ + Val: &ast.TypeCast{ + Arg: &ast.SubLink{SubLinkType: ast.EXPR_SUBLINK, Subselect: query, Location: loc}, + TypeName: nullableTypeName(tn), + Location: loc, + }, + Location: loc, + }}}} +} + +// forClauseType is the type of the document FOR JSON or FOR XML makes, or +// nil for any other FOR clause. FOR XML without TYPE is ntext as a query's +// result but nvarchar(max) as a subquery's. +func forClauseType(fc tsql.ForClause, topLevel bool) *ast.TypeName { + maxText := &ast.TypeName{Name: "nvarchar", Typmods: appendTypmod(nil, &ast.String{Str: "max"})} + switch f := fc.(type) { + case *tsql.JsonForClause: + return maxText + case *tsql.XmlForClause: + for _, o := range f.Options { + if o.OptionKind == "Type" { + return &ast.TypeName{Name: "xml"} + } + } + if topLevel { + return &ast.TypeName{Name: "ntext"} + } + return maxText + } + return nil +} + +// forClauseColumn is the name SQL Server gives the column FOR JSON or FOR +// XML returns, which XML with TYPE leaves unnamed. +func forClauseColumn(fc tsql.ForClause, tn *ast.TypeName) string { + switch { + case tn.Name == "xml": + return "" + case fc != nil: + if _, ok := fc.(*tsql.JsonForClause); ok { + return identifier("JSON_F52E2B61-18A1-11d1-B105-00805F49916B") + } + return identifier("XML_F52E2B61-18A1-11d1-B105-00805F49916B") + } + return "" +} + func (c *cc) convertSelectElement(elem tsql.SelectElement) ast.Node { switch e := elem.(type) { case *tsql.SelectScalarExpression: From 7292623592e5418c0ab8ff594d22f0c95d9b322a Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:54:20 -0800 Subject: [PATCH 25/74] mssql: support views CREATE VIEW was ignored, so a query reading a view failed as an unknown relation. CREATE VIEW, CREATE OR ALTER VIEW and ALTER VIEW now convert to the view statement the core already records, with the columns its query selects or its column list names, and DROP VIEW drops it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_views/mssql/exec.json | 5 + .../testdata/analyze_views/mssql/query.sql | 10 ++ .../testdata/analyze_views/mssql/schema.sql | 38 ++++++ .../testdata/analyze_views/mssql/stdout.json | 127 ++++++++++++++++++ internal/engine/mssql/convert.go | 32 +++++ 5 files changed, 212 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_views/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_views/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_views/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_views/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_views/mssql/exec.json b/internal/endtoend/testdata/analyze_views/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_views/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_views/mssql/query.sql b/internal/endtoend/testdata/analyze_views/mssql/query.sql new file mode 100644 index 0000000000..29aded2c0d --- /dev/null +++ b/internal/endtoend/testdata/analyze_views/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: AuthorNames :many +SELECT * FROM author_names WHERE id = @id; + +-- name: AuthorStats :many +SELECT s.author_id, s.book_count, s.longest, n.name +FROM author_stats s +JOIN author_names n ON n.id = s.author_id; + +-- name: ShortBooks :many +SELECT * FROM reporting.short_books; diff --git a/internal/endtoend/testdata/analyze_views/mssql/schema.sql b/internal/endtoend/testdata/analyze_views/mssql/schema.sql new file mode 100644 index 0000000000..72a0871d52 --- /dev/null +++ b/internal/endtoend/testdata/analyze_views/mssql/schema.sql @@ -0,0 +1,38 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX) +); + +CREATE TABLE books ( + id BIGINT PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL, + pages INT +); +GO + +CREATE VIEW author_names AS SELECT id, name FROM authors; +GO + +CREATE VIEW dbo.author_stats (author_id, book_count, longest) AS +SELECT a.id, COUNT(b.id), MAX(b.pages) +FROM authors a +LEFT JOIN books b ON b.author_id = a.id +GROUP BY a.id; +GO + +CREATE SCHEMA reporting; +GO + +CREATE OR ALTER VIEW reporting.short_books AS +SELECT id, title, pages FROM books WHERE pages < 100; +GO + +CREATE VIEW retired AS SELECT id FROM books; +GO + +DROP VIEW IF EXISTS retired; +GO + +ALTER VIEW author_names AS SELECT id, name, bio FROM authors; diff --git a/internal/endtoend/testdata/analyze_views/mssql/stdout.json b/internal/endtoend/testdata/analyze_views/mssql/stdout.json new file mode 100644 index 0000000000..16b48bf994 --- /dev/null +++ b/internal/endtoend/testdata/analyze_views/mssql/stdout.json @@ -0,0 +1,127 @@ +[ + { + "name": "AuthorNames", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "author_names" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "author_names" + }, + { + "name": "bio", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + }, + "table": "author_names" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "author_names" + } + } + ] + }, + { + "name": "AuthorStats", + "cmd": ":many", + "columns": [ + { + "name": "author_id", + "type": { + "name": "bigint" + }, + "table": "author_stats" + }, + { + "name": "book_count", + "type": { + "name": "int" + }, + "table": "author_stats" + }, + { + "name": "longest", + "type": { + "name": "int", + "nullable": true + }, + "table": "author_stats" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "author_names" + } + ], + "params": [] + }, + { + "name": "ShortBooks", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "short_books" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "short_books" + }, + { + "name": "pages", + "type": { + "name": "int", + "nullable": true + }, + "table": "short_books" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 8c79af527c..082d542687 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -66,11 +66,43 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertAlterTableDropTableElementStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) + case *tsql.CreateViewStatement: + return c.convertView(n.SchemaObjectName, n.Columns, n.SelectStatement, false) + case *tsql.CreateOrAlterViewStatement: + return c.convertView(n.SchemaObjectName, n.Columns, n.SelectStatement, true) + case *tsql.AlterViewStatement: + return c.convertView(n.SchemaObjectName, n.Columns, n.SelectStatement, true) + case *tsql.DropViewStatement: + stmt := &ast.DropTableStmt{IfExists: n.IsIfExists} + for _, obj := range n.Objects { + stmt.Tables = append(stmt.Tables, parseTableName(obj)) + } + return stmt default: return todo(n) } } +// convertView converts CREATE VIEW, and CREATE OR ALTER VIEW and ALTER VIEW, +// which replace the view. +func (c *cc) convertView(name *tsql.SchemaObjectName, cols []*tsql.Identifier, sel *tsql.SelectStatement, replace bool) ast.Node { + if name == nil || sel == nil { + return todo(sel) + } + stmt := &ast.ViewStmt{ + View: c.parseRangeVar(name), + Query: c.convertSelectStatement(sel), + Replace: replace, + } + if len(cols) > 0 { + stmt.Aliases = &ast.List{} + for _, col := range cols { + stmt.Aliases.Items = append(stmt.Aliases.Items, NewIdentifier(col.Value)) + } + } + return stmt +} + // convertCreateTypeUddtStatement reports CREATE TYPE name FROM base [NOT // NULL] as the domain it is: a type standing on its base that may forbid // NULL. From 482269533d07bb515a525fb04b5e313da0d36961 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 13:00:13 -0800 Subject: [PATCH 26/74] mssql: type set operation columns from every branch A UNION, INTERSECT or EXCEPT column was typed from the first branch, as it is named, but SQL Server types it from every branch: the type of highest precedence, varying when either branch varies, with the length, fractional precision or decimal precision and scale that hold both, and reads it from no one table. It is nullable in a UNION when either branch is, in an INTERSECT when both are, and in an EXCEPT when the first is. A dialect may now give these rules as data, in set_operations; SQL Server does. Without them a column is typed from the first branch, as before. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 6 +- internal/core/analyzer/setop.go | 139 ++++++++++++++++ internal/core/dialect.go | 41 +++++ internal/core/seed/seed.go | 13 ++ .../analyze_set_operations/mssql/exec.json | 5 + .../analyze_set_operations/mssql/query.sql | 22 +++ .../analyze_set_operations/mssql/schema.sql | 16 ++ .../analyze_set_operations/mssql/stdout.json | 149 ++++++++++++++++++ .../mssql_correlated_union/mssql/stdout.json | 3 +- internal/engine/mssql/dialect/dialect.json | 19 +++ 10 files changed, 410 insertions(+), 3 deletions(-) create mode 100644 internal/core/analyzer/setop.go create mode 100644 internal/endtoend/testdata/analyze_set_operations/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_set_operations/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 8f301f32ea..fa88e45efa 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -288,11 +288,15 @@ func (a *analyzer) analyzeSetOperation(s *ast.SelectStmt) error { if err != nil { return err } - if _, err := a.subquery(s.Rarg); err != nil { + right, err := a.subquery(s.Rarg) + if err != nil { return err } a.columns = left.columns a.scope = left.scope + if rules := a.cat.SetOperations(); rules != nil { + a.columns = a.combineColumns(rules, s.Op, left.columns, right.columns) + } return nil } diff --git a/internal/core/analyzer/setop.go b/internal/core/analyzer/setop.go new file mode 100644 index 0000000000..a77b6b2944 --- /dev/null +++ b/internal/core/analyzer/setop.go @@ -0,0 +1,139 @@ +package analyzer + +import ( + "slices" + + "github.com/sqlc-dev/sqlc/internal/core" + "github.com/sqlc-dev/sqlc/internal/sql/ast" +) + +// combineColumns types each column of a set operation from both of its +// branches by the dialect's rules. A column keeps the first branch's name +// and is read from no one table. It may be NULL in a UNION when either +// branch's may, in an INTERSECT when both may, and in an EXCEPT when the +// first branch's may, since every row it returns is one of those. +func (a *analyzer) combineColumns(rules *core.SetOperationRules, op ast.SetOperation, left, right []core.Column) []core.Column { + out := make([]core.Column, len(left)) + for i, l := range left { + if i >= len(right) { + out[i] = l + continue + } + r := right[i] + col := core.Column{Name: l.Name, NotNull: l.NotNull && r.NotNull} + switch op { + case ast.Intersect: + col.NotNull = l.NotNull || r.NotNull + case ast.Except: + col.NotNull = l.NotNull + } + t := a.combineTypes(rules, l, r) + t.nullable = !col.NotNull + col.TypeOID = t.typeOID + col.DataType, col.IsArray = a.typeNameOf(t) + col.Type = a.typeExprOf(t) + out[i] = col + } + return out +} + +// combineTypes is the type a column takes from two branches: the one of +// higher precedence, varying when either branch varies, with the length or +// precision that holds both. +func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r core.Column) exprType { + lt, rt := a.exprOf(columnExprType(l)), a.exprOf(columnExprType(r)) + switch { + case lt == nil: + return columnExprType(r) + case rt == nil: + return columnExprType(l) + } + li, ri := slices.Index(rules.Precedence, lt.Name), slices.Index(rules.Precedence, rt.Name) + if li < 0 || ri < 0 { + return columnExprType(l) + } + winner, loser := lt, rt + if ri < li { + winner, loser = rt, lt + } + out := winner.WithNullable(false) + if varying, ok := rules.Varying[out.Name]; ok && slices.Contains(mapValues(rules.Varying), loser.Name) { + out.Name = varying + } + switch { + case out.Name == rules.Decimal && rules.Decimal != "": + combineDecimal(rules, out, loser) + case len(out.Args) == 1 && len(loser.Args) == 1 && a.sameCategory(lt.Name, rt.Name): + out.Args[0] = widerArg(out.Args[0], loser.Args[0]) + } + return a.lookupType(out) +} + +func mapValues(m map[string]string) []string { + out := make([]string, 0, len(m)) + for _, v := range m { + out = append(out, v) + } + return out +} + +// widerArg is the larger of two lengths or precisions, MAX above any. +func widerArg(a, b core.TypeArg) core.TypeArg { + switch { + case a.Ident != nil: + return a + case b.Ident != nil: + return b + case a.Int != nil && b.Int != nil && *b.Int > *a.Int: + return b + } + return a +} + +// combineDecimal gives the exact numeric out the precision and scale that +// hold both it and the other branch's type: the larger scale, and the +// larger count of integer digits, with scale giving way past the maximum +// precision. A family with no decimal form leaves out as it is. +func combineDecimal(rules *core.SetOperationRules, out, other *core.TypeExpr) { + p1, s1, ok1 := decimalForm(rules, out) + p2, s2, ok2 := decimalForm(rules, other) + if !ok1 || !ok2 { + return + } + scale := max(s1, s2) + precision := max(p1-s1, p2-s2) + scale + if limit := rules.DecimalMaxPrecision; limit > 0 && precision > limit { + scale = max(scale-(precision-limit), 0) + precision = limit + } + out.Args = []core.TypeArg{{Int: &precision}, {Int: &scale}} +} + +func decimalForm(rules *core.SetOperationRules, t *core.TypeExpr) (int64, int64, bool) { + if t.Name == rules.Decimal && len(t.Args) == 2 && t.Args[0].Int != nil && t.Args[1].Int != nil { + return *t.Args[0].Int, *t.Args[1].Int, true + } + if form, ok := rules.AsDecimal[t.Name]; ok { + return form[0], form[1], true + } + return 0, 0, false +} + +// sameCategory reports whether two types are of one category, so that the +// length of one says something about the other: the 20 of varchar(20) +// widens an nvarchar(10), but not a datetime2(3). +func (a *analyzer) sameCategory(x, y string) bool { + category := func(name string) string { + oid, err := a.cat.TypeOID(name) + if err != nil { + return "" + } + t, err := a.cat.LookupType(a.familyOID(oid)) + if err != nil { + return "" + } + return t.Category + } + cx := category(x) + return cx != "" && cx == category(y) +} diff --git a/internal/core/dialect.go b/internal/core/dialect.go index 3f8133a825..a96e75992e 100644 --- a/internal/core/dialect.go +++ b/internal/core/dialect.go @@ -2,6 +2,7 @@ package core import ( "context" + "encoding/json" "fmt" "slices" "strings" @@ -82,6 +83,10 @@ const FlagQualifyDuplicateColumns = "columns.qualify_duplicates" // fill them with the type's default instead. const FlagOuterJoinNullable = "joins.outer_nullable" +// FlagSetOperations holds, as JSON, the SetOperationRules a dialect types +// the columns of a set operation by. +const FlagSetOperations = "set_operations" + // FlagReturningAliases holds, comma separated, the names a RETURNING list // may use for the statement's target. const FlagReturningAliases = "returning.aliases" @@ -215,6 +220,42 @@ func (c *Catalog) OuterJoinsNullable() bool { return v == "true" } +// SetOperationRules say how a dialect types a column of UNION, INTERSECT or +// EXCEPT from its branches, as SQL Server does by data type precedence. A +// dialect without them types the column from the first branch. +type SetOperationRules struct { + // Precedence lists type families, highest first: the column takes the + // highest of its branches'. + Precedence []string `json:"precedence"` + // Varying maps a fixed-length family to its varying one, which the + // column takes when another branch varies: char and varchar make + // varchar. + Varying map[string]string `json:"varying,omitempty"` + // Decimal names the exact numeric family, whose precision and scale + // cover every branch's, up to DecimalMaxPrecision, which scale gives + // way to. AsDecimal is the precision and scale another family counts + // as. + Decimal string `json:"decimal,omitempty"` + DecimalMaxPrecision int64 `json:"decimal_max_precision,omitempty"` + AsDecimal map[string][2]int64 `json:"as_decimal,omitempty"` +} + +// SetOperations returns the dialect's set operation rules, or nil. +func (c *Catalog) SetOperations() *SetOperationRules { + if c.dialectOID == 0 { + return nil + } + v, _ := c.DialectFlag(c.dialectOID, FlagSetOperations) + if v == "" { + return nil + } + var rules SetOperationRules + if err := json.Unmarshal([]byte(v), &rules); err != nil { + return nil + } + return &rules +} + // ReturningAliases lists the names a RETURNING list may qualify a column of // the statement's target with, as SQL Server's OUTPUT clause reads // INSERTED.id and DELETED.id. diff --git a/internal/core/seed/seed.go b/internal/core/seed/seed.go index cfbedf69fa..a8e53bde57 100644 --- a/internal/core/seed/seed.go +++ b/internal/core/seed/seed.go @@ -93,6 +93,10 @@ type Settings struct { // INSERTED and DELETED. ReturningAliases []string `json:"returning_aliases,omitempty"` + // SetOperations types a column of a set operation from every branch, + // rather than from the first. + SetOperations *core.SetOperationRules `json:"set_operations,omitempty"` + // Comparison operators are registered as (T, T) -> Bool for every type in // ComparisonCategories. Comparison []string `json:"comparison,omitempty"` @@ -674,6 +678,15 @@ func (b *builder) consts() error { return err } } + if b.settings.SetOperations != nil { + rules, err := json.Marshal(b.settings.SetOperations) + if err != nil { + return err + } + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagSetOperations, string(rules)); err != nil { + return err + } + } if len(b.settings.ReturningAliases) > 0 { if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagReturningAliases, strings.Join(b.settings.ReturningAliases, ",")); err != nil { return err diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/exec.json b/internal/endtoend/testdata/analyze_set_operations/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql new file mode 100644 index 0000000000..24ebd88bd9 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql @@ -0,0 +1,22 @@ +-- name: Everyone :many +SELECT id, name, code, score, joined FROM people WHERE name <> @skip +UNION ALL +SELECT id, title, code, budget, founded FROM orgs; + +-- name: Names :many +SELECT name FROM people +UNION +SELECT nickname FROM people +UNION +SELECT NULL; + +-- name: SharedNicknames :many +SELECT nickname, id FROM people +INTERSECT +SELECT title, id FROM orgs; + +-- name: OnlyPeople :many +SELECT id, score FROM people +EXCEPT +SELECT id, budget FROM orgs; + diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql new file mode 100644 index 0000000000..a1732f75f5 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql @@ -0,0 +1,16 @@ +CREATE TABLE people ( + id INT IDENTITY(1,1) PRIMARY KEY, + name VARCHAR(50) NOT NULL, + nickname NVARCHAR(20), + code CHAR(3) NOT NULL, + score DECIMAL(10,2) NOT NULL, + joined DATETIME2(3) NOT NULL +); + +CREATE TABLE orgs ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + code VARCHAR(5), + budget MONEY NOT NULL, + founded DATE NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json new file mode 100644 index 0000000000..062e10c474 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json @@ -0,0 +1,149 @@ +[ + { + "name": "Everyone", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "code", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "score", + "type": { + "name": "decimal", + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + }, + { + "name": "joined", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "skip", + "type": { + "name": "varchar", + "args": [ + { + "int": 50 + } + ] + }, + "table": "people" + } + } + ] + }, + { + "name": "Names", + "cmd": ":many", + "columns": [ + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + } + ], + "params": [] + }, + { + "name": "SharedNicknames", + "cmd": ":many", + "columns": [ + { + "name": "nickname", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "id", + "type": { + "name": "bigint" + } + } + ], + "params": [] + }, + { + "name": "OnlyPeople", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + } + }, + { + "name": "score", + "type": { + "name": "decimal", + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json index e5228f14f0..addc234e68 100644 --- a/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json @@ -19,8 +19,7 @@ "int": 200 } ] - }, - "table": "books" + } } ], "params": [] diff --git a/internal/engine/mssql/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 1519273f43..647572a7b6 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -11,6 +11,25 @@ "limit": "bigint", "outer_join_nullable": true, "returning_aliases": ["inserted", "deleted"], + "set_operations": { + "precedence": [ + "sql_variant", "xml", "datetimeoffset", "datetime2", "datetime", + "smalldatetime", "date", "time", "float", "real", "decimal", "money", + "smallmoney", "bigint", "int", "smallint", "tinyint", "bit", "ntext", + "text", "image", "rowversion", "uniqueidentifier", "nvarchar", "nchar", + "varchar", "char", "varbinary", "binary" + ], + "varying": {"char": "varchar", "nchar": "nvarchar", "binary": "varbinary"}, + "decimal": "decimal", + "decimal_max_precision": 38, + "as_decimal": { + "tinyint": [3, 0], + "smallint": [5, 0], + "bigint": [19, 0], + "money": [19, 4], + "smallmoney": [10, 4] + } + }, "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="], "comparison_categories": "NBSD", "arithmetic": ["+", "-", "*", "/", "%"], From 1e9e0bde796516cde972ab1d654ba10f85c618cf Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:23:05 -0800 Subject: [PATCH 27/74] golang: read a result variable's first character as a rune MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit goIdent checked the first byte of a column name for a digit, so a name starting with a non-ASCII digit, such as [١total], kept it and did not compile, and a name with no identifier characters at all, such as [!], became the blank identifier. The first rune is now checked, and a name left with nothing but underscores falls back to column_1, as an unnamed column is called. Addresses review comment r4557024827 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/codegen/golang/result.go | 6 ++- .../mssql/go/query.sql.go | 54 +++++++++++++++++++ .../mssql/query.sql | 6 +++ 3 files changed, 65 insertions(+), 1 deletion(-) diff --git a/internal/codegen/golang/result.go b/internal/codegen/golang/result.go index 0290e6c89d..d2f56b7736 100644 --- a/internal/codegen/golang/result.go +++ b/internal/codegen/golang/result.go @@ -6,6 +6,7 @@ import ( "sort" "strings" "unicode" + "unicode/utf8" "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" "github.com/sqlc-dev/sqlc/internal/codegen/sdk" @@ -176,7 +177,10 @@ func goIdent(name string) string { } return '_' }, name) - if name != "" && unicode.IsDigit(rune(name[0])) { + if strings.Trim(name, "_") == "" { + return "column_1" + } + if r, _ := utf8.DecodeRuneInString(name); unicode.IsDigit(r) { name = "_" + name } return name diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go index 47d0bf7ccc..fecf1691be 100644 --- a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go @@ -10,6 +10,60 @@ import ( "database/sql" ) +const leadingUnicodeDigit = `-- name: LeadingUnicodeDigit :many +SELECT amount AS [١total] FROM sales; +` + +func (q *Queries) LeadingUnicodeDigit(ctx context.Context) ([]int32, error) { + rows, err := q.db.QueryContext(ctx, leadingUnicodeDigit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []int32 + for rows.Next() { + var _١total int32 + if err := rows.Scan(&_١total); err != nil { + return nil, err + } + items = append(items, _١total) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const noIdentifierCharacters = `-- name: NoIdentifierCharacters :many +SELECT amount AS [!] FROM sales; +` + +func (q *Queries) NoIdentifierCharacters(ctx context.Context) ([]int32, error) { + rows, err := q.db.QueryContext(ctx, noIdentifierCharacters) + if err != nil { + return nil, err + } + defer rows.Close() + var items []int32 + for rows.Next() { + var column_1 int32 + if err := rows.Scan(&column_1); err != nil { + return nil, err + } + items = append(items, column_1) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const sales2023 = `-- name: Sales2023 :many SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; ` diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql index 735d3bcfae..3e8cf1be87 100644 --- a/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql @@ -3,3 +3,9 @@ SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; -- name: TotalForAuthor :one SELECT [total amount] = SUM(amount) FROM sales WHERE author_id = @author_id; + +-- name: LeadingUnicodeDigit :many +SELECT amount AS [١total] FROM sales; + +-- name: NoIdentifierCharacters :many +SELECT amount AS [!] FROM sales; From 70a715028afd4fd435d5bdfaeb65c4b79747f946 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:24:14 -0800 Subject: [PATCH 28/74] golang: expand every use of a named slice A query that uses one sqlc.slice() twice binds a single parameter, but the generated code for a query bound by name replaced only the first /*SLICE:x*/@x marker, leaving the others unbound. Every marker is now replaced with the same placeholders, which the driver binds by position however many times they appear. Addresses review comment r4557024903 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../golang/templates/stdlib/queryCode.tmpl | 8 +-- .../mssql_sqlc_macros/mssql/go/query.sql.go | 52 +++++++++++++++++-- .../mssql_sqlc_macros/mssql/query.sql | 3 ++ 3 files changed, 55 insertions(+), 8 deletions(-) diff --git a/internal/codegen/golang/templates/stdlib/queryCode.tmpl b/internal/codegen/golang/templates/stdlib/queryCode.tmpl index f0fe0189ef..827fc8c951 100644 --- a/internal/codegen/golang/templates/stdlib/queryCode.tmpl +++ b/internal/codegen/golang/templates/stdlib/queryCode.tmpl @@ -140,9 +140,9 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} queryParams = append(queryParams, v) placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) } - query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", strings.Join(placeholders, ","), 1) + query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", strings.Join(placeholders, ",")) } else { - query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", "NULL", 1) + query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", "NULL") } {{- else if .HasSqlcSlice }} if len({{$arg.VariableForField .}}) > 0 { @@ -171,9 +171,9 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} queryParams = append(queryParams, v) placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) } - query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", strings.Join(placeholders, ","), 1) + query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", strings.Join(placeholders, ",")) } else { - query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", "NULL", 1) + query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", "NULL") } {{- else }} if len({{.Arg.Name}}) > 0 { diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go index b93d8cbec6..d6a425f9f4 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go @@ -89,9 +89,9 @@ func (q *Queries) ListAuthorsByIDs(ctx context.Context, ids []int64) ([]ListAuth queryParams = append(queryParams, v) placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) } - query = strings.Replace(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ","), 1) + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) } else { - query = strings.Replace(query, "/*SLICE:ids*/@ids", "NULL", 1) + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") } rows, err := q.db.QueryContext(ctx, query, queryParams...) if err != nil { @@ -139,9 +139,9 @@ func (q *Queries) ListAuthorsByIDsAndName(ctx context.Context, arg ListAuthorsBy queryParams = append(queryParams, v) placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) } - query = strings.Replace(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ","), 1) + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) } else { - query = strings.Replace(query, "/*SLICE:ids*/@ids", "NULL", 1) + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") } rows, err := q.db.QueryContext(ctx, query, queryParams...) if err != nil { @@ -165,6 +165,50 @@ func (q *Queries) ListAuthorsByIDsAndName(ctx context.Context, arg ListAuthorsBy return items, nil } +const listAuthorsByIDsTwice = `-- name: ListAuthorsByIDsTwice :many +SELECT id, name FROM authors WHERE id IN (/*SLICE:ids*/@ids) OR id + 100 IN (/*SLICE:ids*/@ids); +` + +type ListAuthorsByIDsTwiceRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDsTwice(ctx context.Context, ids []int64) ([]ListAuthorsByIDsTwiceRow, error) { + query := listAuthorsByIDsTwice + var queryParams []any + if len(ids) > 0 { + var placeholders []string + for _, v := range ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsTwiceRow + for rows.Next() { + var i ListAuthorsByIDsTwiceRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const rowCount = `-- name: RowCount :one SELECT CAST(@@ROWCOUNT AS INT) AS row_count; ` diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql index be9e4fc7a2..37529badea 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql @@ -18,3 +18,6 @@ SELECT sqlc.embed(a), sqlc.embed(books), books.title AS book_title FROM authors a JOIN books ON books.author_id = a.id WHERE a.id = sqlc.arg(author_id) ORDER BY books.id; + +-- name: ListAuthorsByIDsTwice :many +SELECT id, name FROM authors WHERE id IN (sqlc.slice(ids)) OR id + 100 IN (sqlc.slice(ids)); From bb4e52797f0f45970853d1a81e9bf365a8dea3de Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:25:26 -0800 Subject: [PATCH 29/74] mssql: expand a star qualified with double quotes Star expansion measures the reference it replaces by the quoting the dialect writes, which for SQL Server became brackets. A qualifier the user wrote in double quotes, which SQL Server also reads as an identifier, no longer matched, so "o".* was replaced only in part and left broken SQL. A double-quoted qualifier is now measured as written. Addresses review comment r4557024959 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/expand.go | 4 +++ .../mssql_star_quoting/mssql/go/query.sql.go | 27 +++++++++++++++++++ .../mssql_star_quoting/mssql/query.sql | 3 +++ 3 files changed, 34 insertions(+) diff --git a/internal/compiler/expand.go b/internal/compiler/expand.go index b7e5d12605..64ed0693d8 100644 --- a/internal/compiler/expand.go +++ b/internal/compiler/expand.go @@ -110,6 +110,10 @@ func (c *Compiler) starOldFunc(parts []string) func(string) int { length += len(o) } else if quoted := c.quote(o); strings.HasPrefix(s[length:], quoted) { length += len(quoted) + } else if quoted := `"` + o + `"`; 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) } diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go index f620a15220..f145d188af 100644 --- a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go @@ -37,6 +37,33 @@ func (q *Queries) ListOrders(ctx context.Context) ([]Order, error) { return items, nil } +const listOrdersDoubleQuoted = `-- name: ListOrdersDoubleQuoted :many +SELECT o.id, o.[select], o.[weird]]name] FROM [order] "o"; +` + +func (q *Queries) ListOrdersDoubleQuoted(ctx context.Context) ([]Order, error) { + rows, err := q.db.QueryContext(ctx, listOrdersDoubleQuoted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Order + for rows.Next() { + var i Order + if err := rows.Scan(&i.ID, &i.Select, &i.WeirdName); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const salesByYear = `-- name: SalesByYear :many SELECT pv.author_id, pv.[2023], pv.[2024] FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; ` diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql index dc4f48900c..8f19dc927f 100644 --- a/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql @@ -3,3 +3,6 @@ SELECT o.* FROM [order] o; -- name: SalesByYear :many SELECT pv.* FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; + +-- name: ListOrdersDoubleQuoted :many +SELECT "o".* FROM [order] "o"; From 89088c569f77fdff11d186f0aa75cecb5f8ba351 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:27:23 -0800 Subject: [PATCH 30/74] mssql: embed a table only when the star is all of its columns sqlc.embed() on the core path folded a star into the table its first column came from, whatever else the star expanded to. The struct scans every column of the table in order, so an embed of a subquery that selects some of its columns, or reorders them, scanned the wrong number of values or into the wrong fields. A star is now folded only when it is exactly the table's columns in order, and is otherwise left flat. Addresses review comment r4557025012 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/parse_core.go | 46 +++++++++++-- .../mssql_sqlc_macros/mssql/go/query.sql.go | 65 +++++++++++++++++++ .../mssql_sqlc_macros/mssql/query.sql | 6 ++ 3 files changed, 113 insertions(+), 4 deletions(-) diff --git a/internal/compiler/parse_core.go b/internal/compiler/parse_core.go index 49840002cc..5679f39dd6 100644 --- a/internal/compiler/parse_core.go +++ b/internal/compiler/parse_core.go @@ -64,7 +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) + cols = embedColumns(raw, cols, res.Stars, pre.Embeds, c.coreCatalog) placeholders, err := placeholderNames(raw) if err != nil { return nil, err @@ -108,8 +108,10 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess. // embedColumns folds the columns each sqlc.embed() star expanded to into // the one column codegen embeds the table's struct for. The table is the -// columns' source, so an embed of an alias names the table behind it. -func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, embeds preprocess.EmbedSet) []*Column { +// 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 @@ -135,7 +137,7 @@ func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, if !ok || i+n > len(cols) { return cols } - if embed, ok := embeds.Find(ref.Location, res.Location); ok && n > 0 && cols[i].Table != nil { + 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]...) @@ -145,6 +147,42 @@ func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, return out } +// isWholeTable reports whether cols are every column of one table, in the +// table's order. +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 { + return false + } + i++ + } + return i == len(cols) +} + func coreColumn(c core.Column) *Column { col := &Column{ Name: c.Name, diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go index d6a425f9f4..4bad0e6fab 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go @@ -71,6 +71,71 @@ func (q *Queries) CreateAuthor(ctx context.Context, arg CreateAuthorParams) erro return err } +const embedNarrowSubquery = `-- name: EmbedNarrowSubquery :many +SELECT x.id, x.name FROM (SELECT id, name FROM authors) x; +` + +type EmbedNarrowSubqueryRow struct { + ID int64 + Name string +} + +func (q *Queries) EmbedNarrowSubquery(ctx context.Context) ([]EmbedNarrowSubqueryRow, error) { + rows, err := q.db.QueryContext(ctx, embedNarrowSubquery) + if err != nil { + return nil, err + } + defer rows.Close() + var items []EmbedNarrowSubqueryRow + for rows.Next() { + var i EmbedNarrowSubqueryRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const embedReorderedSubquery = `-- name: EmbedReorderedSubquery :many +SELECT x.name, x.id, x.bio FROM (SELECT name, id, bio FROM authors) x; +` + +type EmbedReorderedSubqueryRow struct { + Name string + ID int64 + Bio sql.NullString +} + +func (q *Queries) EmbedReorderedSubquery(ctx context.Context) ([]EmbedReorderedSubqueryRow, error) { + rows, err := q.db.QueryContext(ctx, embedReorderedSubquery) + if err != nil { + return nil, err + } + defer rows.Close() + var items []EmbedReorderedSubqueryRow + for rows.Next() { + var i EmbedReorderedSubqueryRow + if err := rows.Scan(&i.Name, &i.ID, &i.Bio); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const listAuthorsByIDs = `-- name: ListAuthorsByIDs :many SELECT id, name FROM authors WHERE id IN (/*SLICE:ids*/@ids) ORDER BY id; ` diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql index 37529badea..3c973ed232 100644 --- a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql @@ -21,3 +21,9 @@ ORDER BY books.id; -- name: ListAuthorsByIDsTwice :many SELECT id, name FROM authors WHERE id IN (sqlc.slice(ids)) OR id + 100 IN (sqlc.slice(ids)); + +-- name: EmbedNarrowSubquery :many +SELECT sqlc.embed(x) FROM (SELECT id, name FROM authors) x; + +-- name: EmbedReorderedSubquery :many +SELECT sqlc.embed(x) FROM (SELECT name, id, bio FROM authors) x; From ca3c8e046183affb2fde3ad88ab52703dae96abc Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:33:39 -0800 Subject: [PATCH 31/74] core: keep a WITH clause's names out of the enclosing query The analyzers of nested queries share the map of CTEs they inherit, so a WITH clause in a subquery added its names to the enclosing query's map, where a CTE could hide a table of the same name: with an inner WITH authors AS (...), a later SELECT name FROM authors in the outer query read the CTE and failed. A WITH clause now binds its names in its own copy of the map. Addresses review comment r4557025055 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/analyzer.go | 10 +++++--- .../analyze_cte_scope/postgresql/exec.json | 5 ++++ .../analyze_cte_scope/postgresql/query.sql | 6 +++++ .../analyze_cte_scope/postgresql/schema.sql | 1 + .../analyze_cte_scope/postgresql/stdout.json | 23 +++++++++++++++++++ 5 files changed, 42 insertions(+), 3 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json create mode 100644 internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql create mode 100644 internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index fa88e45efa..8b97dc10d1 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -2,6 +2,7 @@ package analyzer import ( "fmt" + "maps" "github.com/sqlc-dev/sqlc/internal/core" "github.com/sqlc-dev/sqlc/internal/sql/ast" @@ -306,6 +307,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 { @@ -315,9 +322,6 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error { if !ok { continue } - if a.ctes == nil { - a.ctes = map[string]scopeRel{} - } // 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) diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json b/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json new file mode 100644 index 0000000000..b102755fb6 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "postgresql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql b/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql new file mode 100644 index 0000000000..148528dcd1 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql @@ -0,0 +1,6 @@ +-- name: InnerWithDoesNotLeak :one +WITH x AS (SELECT 1 AS n) +SELECT + (SELECT count(*) FROM (WITH authors AS (SELECT 1 AS id) SELECT id FROM authors) s) AS inner_count, + (SELECT name FROM authors LIMIT 1) AS outer_name +FROM x; diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql b/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql new file mode 100644 index 0000000000..b1098ab8ff --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE authors (id int PRIMARY KEY, name text NOT NULL); diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json b/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json new file mode 100644 index 0000000000..5794ccc393 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json @@ -0,0 +1,23 @@ +[ + { + "name": "InnerWithDoesNotLeak", + "cmd": ":one", + "columns": [ + { + "name": "inner_count", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "outer_name", + "type": { + "name": "text", + "nullable": true + } + } + ], + "params": [] + } +] From 2256c3fea73aad3a10a4598187df9b634bf170ae Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:35:30 -0800 Subject: [PATCH 32/74] mssql: leave bracketed identifiers alone when preprocessing The preprocessor skips the quoted regions of a query, but did not know SQL Server's bracketed identifiers, so [sqlc.arg(x)] was rewritten to [@x], an @name inside brackets was taken for a parameter, and a semicolon inside them split the statement. A dialect may now say that [...] quotes an identifier, with ]] standing for a bracket in it, and SQL Server does. Addresses review comment r4557025105 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/sql/preprocess/CLAUDE.md | 6 +++--- internal/sql/preprocess/dialect.go | 5 +++++ internal/sql/preprocess/lexer.go | 5 +++++ .../mssql/skip_bracketed_identifiers/input.sql | 2 ++ .../mssql/skip_bracketed_identifiers/output.sql | 2 ++ .../skip_bracketed_identifiers/side_table.json | 16 ++++++++++++++++ 6 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json diff --git a/internal/sql/preprocess/CLAUDE.md b/internal/sql/preprocess/CLAUDE.md index 2f8a48f67f..cf468c91c0 100644 --- a/internal/sql/preprocess/CLAUDE.md +++ b/internal/sql/preprocess/CLAUDE.md @@ -31,9 +31,9 @@ looks like. `lexer` is a dialect-parameterized scanner. It does not parse SQL — it knows only enough to skip the regions where sqlc syntax must not be rewritten: -comments (`--`, `/* */`, `#`), string literals, quoted identifiers, backticks -and PostgreSQL dollar-quoted strings. `Dialect` (dialect.go) is the single -place those lexical rules live. +comments (`--`, `/* */`, `#`), string literals, quoted identifiers, backticks, +SQL Server brackets and PostgreSQL dollar-quoted strings. `Dialect` +(dialect.go) is the single place those lexical rules live. `File(engine, src)` looks up the dialect; an engine with no entry gets its source back untouched. Otherwise it walks the whole file, splits it at diff --git a/internal/sql/preprocess/dialect.go b/internal/sql/preprocess/dialect.go index 4098512086..3ed78281dd 100644 --- a/internal/sql/preprocess/dialect.go +++ b/internal/sql/preprocess/dialect.go @@ -44,6 +44,10 @@ type Dialect struct { // Backtick reports whether `ident` is a quoted identifier. Backtick bool + // Bracket reports whether [ident] is a quoted identifier, with ]] + // standing for a closing bracket in it. + Bracket bool + // HashComment reports whether # starts a line comment. HashComment bool @@ -95,6 +99,7 @@ var dialects = map[config.Engine]Dialect{ config.EngineMSSQL: { Style: StyleAt, AtSign: true, + Bracket: true, NestedBlockComment: true, }, // ClickHouse binds with an unnumbered ?, like MySQL, and its identifiers diff --git a/internal/sql/preprocess/lexer.go b/internal/sql/preprocess/lexer.go index d17d80b077..7c9568c3c2 100644 --- a/internal/sql/preprocess/lexer.go +++ b/internal/sql/preprocess/lexer.go @@ -53,6 +53,11 @@ func (l *lexer) skip(i int) int { return -1 } return l.skipQuoted(i, '`', false) + case '[': + if !l.d.Bracket { + return -1 + } + return l.skipQuoted(i, ']', false) case '-': if l.at(i+1) == '-' { return l.skipLine(i) diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql new file mode 100644 index 0000000000..cadc2e6fac --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql @@ -0,0 +1,2 @@ +-- name: Bracketed :many +SELECT [sqlc.arg(x)], [a;b], [@id], [x]]@y] FROM t WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql new file mode 100644 index 0000000000..cadc2e6fac --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql @@ -0,0 +1,2 @@ +-- name: Bracketed :many +SELECT [sqlc.arg(x)], [a;b], [@id], [x]]@y] FROM t WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json new file mode 100644 index 0000000000..b66e867f66 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json @@ -0,0 +1,16 @@ +[ + { + "start": 0, + "end": 91, + "dollar": true, + "params": [ + { + "number": 1, + "location": 87, + "origin": 87, + "name": "id", + "named": true + } + ] + } +] From 29109a29862b1fcfa64c7c68b40e802ade6c4c89 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:37:02 -0800 Subject: [PATCH 33/74] mssql: reject a macro name that is not a valid @name SQL Server binds a parameter by the name sqlc writes into the query, so sqlc.arg('user-id') became @user-id, which the server reads as @user minus id, and a name with a space did not parse; the generated Go did not compile either way. For a dialect that binds @name, a name passed to sqlc.arg, sqlc.narg or sqlc.slice must now be one an @name can spell, and is otherwise reported at the call. Addresses review comment r4557025173 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/sql/preprocess/scan.go | 21 +++++++++++++++++++ .../mssql/error_invalid_param_name/input.sql | 2 ++ .../mssql/error_invalid_param_name/output.sql | 2 ++ .../error_invalid_param_name/side_table.json | 9 ++++++++ .../mssql/error_invalid_param_name/stderr.txt | 1 + 5 files changed, 35 insertions(+) create mode 100644 internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json create mode 100644 internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt diff --git a/internal/sql/preprocess/scan.go b/internal/sql/preprocess/scan.go index a6245e5704..feafe91ddc 100644 --- a/internal/sql/preprocess/scan.go +++ b/internal/sql/preprocess/scan.go @@ -139,11 +139,32 @@ func (l *lexer) sqlcCall(start, afterSqlc int) (occurrence, int, bool) { } return occ, occ.end, true } + // A dialect that binds @name writes the name into the query, so it has + // to read back as one parameter: @user-id would be a subtraction. + if l.d.Style == StyleAt && !isParamName(name) { + occ.err = &sqlerr.Error{ + Message: fmt.Sprintf("parameter name %q passed to sqlc.%s is not a valid @name; use letters, digits and underscores", name, fn), + Location: start, + } + return occ, occ.end, true + } occ.name = name occ.ident = ident return occ, occ.end, true } +func isParamName(name string) bool { + if name == "" || !isIdentStart(name[0]) { + return false + } + for i := 1; i < len(name); i++ { + if !isIdentPart(name[i]) { + return false + } + } + return true +} + // argument interprets the single argument to a sqlc function. It returns the // parameter name and the text to reuse when rebuilding a reference, which keeps // any identifier quoting the user wrote. diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql new file mode 100644 index 0000000000..5e5891a8b2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql @@ -0,0 +1,2 @@ +-- name: Bad :many +SELECT id FROM t WHERE user_id = sqlc.arg('user-id') - 1; diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql new file mode 100644 index 0000000000..5e5891a8b2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql @@ -0,0 +1,2 @@ +-- name: Bad :many +SELECT id FROM t WHERE user_id = sqlc.arg('user-id') - 1; diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json new file mode 100644 index 0000000000..e0e4768647 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json @@ -0,0 +1,9 @@ +[ + { + "start": 0, + "end": 76, + "dollar": true, + "error": "parameter name \"user-id\" passed to sqlc.arg is not a valid @name; use letters, digits and underscores", + "error_at": 52 + } +] diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt new file mode 100644 index 0000000000..89416c54d3 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt @@ -0,0 +1 @@ +2:34: parameter name "user-id" passed to sqlc.arg is not a valid @name; use letters, digits and underscores From a63e9eda957cdf761dd746835e6edfa86355da2e Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:38:51 -0800 Subject: [PATCH 34/74] mssql: keep the length and precision of a computed column A computed column took the type its expression was analyzed as, but the analysis reports the family's row for a type with arguments no column has interned, so CAST(price AS nvarchar(37)) was stored as nvarchar and read back as the nvarchar(1) a bare declaration means. A type with arguments is now resolved as the whole expression. Addresses review comment r4557025274 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/schema/schema.go | 5 +- .../analyze_computed_columns/mssql/query.sql | 2 +- .../analyze_computed_columns/mssql/schema.sql | 4 +- .../mssql/stdout.json | 58 +++++++++++++++++++ 4 files changed, 65 insertions(+), 4 deletions(-) diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index 19e9cb68e8..35def91fd7 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -224,8 +224,9 @@ func applyGenerated(cat *core.Catalog, classOID int64, table *ast.TableName, col if r, err := analyzer.Prepare(cat, sel); err == nil && len(r.Columns) == 1 { res, typeOID = r.Columns[0], r.Columns[0].TypeOID // An expression's type may carry arguments, as decimal(10,2) does, - // that no column has interned yet. - if typeOID == 0 && res.Type != nil { + // that no column has interned yet, and for which the analysis + // reports the family's row. + if res.Type != nil && (typeOID == 0 || len(res.Type.Args) > 0) { t := *res.Type t.Nullable = false typeOID, _ = cat.ResolveTypeExpr(&t) diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql b/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql index a2566b032e..e45b519cf7 100644 --- a/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql @@ -1,5 +1,5 @@ -- name: GetComputed :one -SELECT total, doubled, doubled_nn, label, full_label, bio_label, cost, c_isnull, extra +SELECT total, doubled, doubled_nn, label, full_label, bio_label, cost, c_isnull, precise, price_text, extra FROM authors WHERE id = @id; diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql index e83f8ca705..ff84b7616d 100644 --- a/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql @@ -10,7 +10,9 @@ CREATE TABLE authors ( full_label AS (CONCAT(name, bio)), bio_label AS (bio + N'?'), cost AS (CAST(price AS decimal(10,2))), - c_isnull AS (ISNULL(bio, N'none')) + c_isnull AS (ISNULL(bio, N'none')), + precise AS (CAST(price AS decimal(17,9))), + price_text AS (CAST(price AS nvarchar(37))) ); ALTER TABLE authors ADD extra AS (price + 1); diff --git a/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json index 140680e737..f84f5ad7eb 100644 --- a/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -77,6 +77,35 @@ }, "table": "authors" }, + { + "name": "precise", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 17 + }, + { + "int": 9 + } + ] + }, + "table": "authors" + }, + { + "name": "price_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 37 + } + ] + }, + "table": "authors" + }, { "name": "extra", "type": { @@ -216,6 +245,35 @@ }, "table": "authors" }, + { + "name": "precise", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 17 + }, + { + "int": 9 + } + ] + }, + "table": "authors" + }, + { + "name": "price_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 37 + } + ] + }, + "table": "authors" + }, { "name": "extra", "type": { From 6c8bf76900d3d592b5ff06d914d1f8638193b2fc Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:44:31 -0800 Subject: [PATCH 35/74] mssql: count int and bit as decimals when combining types A set operation combining an int or bit with a decimal kept the decimal's precision, which is what SQL Server reports for a NULL constant of those types, but not for a column: an int column counts as decimal(10, 0) and a bit as decimal(1, 0), so int UNION ALL decimal(5,2) is decimal(12,2). Addresses review comment r4557025343 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_set_operations/mssql/query.sql | 7 +++++++ .../analyze_set_operations/mssql/schema.sql | 6 ++++++ .../analyze_set_operations/mssql/stdout.json | 21 +++++++++++++++++++ internal/engine/mssql/dialect/dialect.json | 2 ++ 4 files changed, 36 insertions(+) diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql index 24ebd88bd9..f52cdad03c 100644 --- a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql @@ -20,3 +20,10 @@ SELECT id, score FROM people EXCEPT SELECT id, budget FROM orgs; + +-- name: Amounts :many +SELECT qty AS v FROM ledger +UNION ALL +SELECT amount FROM ledger +UNION ALL +SELECT flag FROM ledger; diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql index a1732f75f5..d5863672a6 100644 --- a/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql @@ -14,3 +14,9 @@ CREATE TABLE orgs ( budget MONEY NOT NULL, founded DATE NOT NULL ); + +CREATE TABLE ledger ( + qty INT NOT NULL, + flag BIT NOT NULL, + amount DECIMAL(5,2) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json index 062e10c474..c7cd695f18 100644 --- a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json @@ -145,5 +145,26 @@ } ], "params": [] + }, + { + "name": "Amounts", + "cmd": ":many", + "columns": [ + { + "name": "v", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [] } ] diff --git a/internal/engine/mssql/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 647572a7b6..a038bad0ec 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -23,8 +23,10 @@ "decimal": "decimal", "decimal_max_precision": 38, "as_decimal": { + "bit": [1, 0], "tinyint": [3, 0], "smallint": [5, 0], + "int": [10, 0], "bigint": [19, 0], "money": [19, 4], "smallmoney": [10, 4] From a42d1e1e784e69b20671fda3b7c58a278c4809ac Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:49:21 -0800 Subject: [PATCH 36/74] mssql: type CASE, COALESCE, GREATEST, LEAST and CHOOSE by precedence These yield one of several values, and were typed as the first typed one, so CASE WHEN on_sale THEN 0 ELSE price END was an int and generated an int32 the decimal price could not scan into. SQL Server types them as it does a set operation's columns: the candidates' types combined by data type precedence. They now are, by the dialect's set_operations rules; a dialect without them types them as before. GREATEST and LEAST convert to the min/max node and CHOOSE to the CASE over its index it is defined as, whose placeholder now takes the type of what it is compared with. ISNULL keeps its first argument's type, as SQL Server gives it. Addresses review comment r4557025398 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/expr.go | 50 ++++--- internal/core/analyzer/setop.go | 38 +++++- .../analyze_combined_types/mssql/exec.json | 5 + .../analyze_combined_types/mssql/query.sql | 10 ++ .../analyze_combined_types/mssql/schema.sql | 1 + .../analyze_combined_types/mssql/stdout.json | 122 ++++++++++++++++++ internal/engine/mssql/convert.go | 47 +++++-- internal/engine/mssql/dialect/functions.jsonl | 3 - internal/sql/ast/coalesce_expr.go | 3 + 9 files changed, 241 insertions(+), 38 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_combined_types/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_combined_types/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json diff --git a/internal/core/analyzer/expr.go b/internal/core/analyzer/expr.go index 14b23bcfc1..8925f69be4 100644 --- a/internal/core/analyzer/expr.go +++ b/internal/core/analyzer/expr.go @@ -465,6 +465,13 @@ func (a *analyzer) typeCase(e *ast.CaseExpr) (exprType, error) { continue } // "CASE x WHEN y" compares y against x; "CASE WHEN y" is a predicate. + // A placeholder for x takes the type of what it is compared with. + if pr, ok := e.Arg.(*ast.ParamRef); ok && argT.typeOID == 0 && argT.expr == nil { + if argT, err = a.typeExpr(when.Expr); err != nil { + return exprType{}, err + } + a.inferParam(pr, argT) + } if e.Arg != nil { if err := a.typeOperands(when.Expr, argT); err != nil { return exprType{}, err @@ -484,45 +491,48 @@ func (a *analyzer) typeCase(e *ast.CaseExpr) (exprType, error) { return t, nil } -// typeCoalesce types COALESCE, which is its first typed argument's type and -// is null only when every argument is. +// typeCoalesce types COALESCE, which is null only when every argument is, +// and of the type its arguments combine to, or its first typed argument's +// for SQL Server's ISNULL. func (a *analyzer) typeCoalesce(e *ast.CoalesceExpr) (exprType, error) { - var out exprType - found := false + types := make([]exprType, 0, len(listItems(e.Args))) nullable := true for _, n := range listItems(e.Args) { t, err := a.typeExpr(n) if err != nil { return exprType{}, err } - if !found && (t.typeOID != 0 || t.expr != nil) { - // The result is an expression's, not the column's it came from. - out = exprType{typeOID: t.typeOID, expr: t.expr} - found = true - } + types = append(types, t) nullable = nullable && t.nullable } - out.nullable = nullable - return out, nil + t := a.commonType(types) + if e.FirstArgType { + for _, first := range types { + if first.typeOID != 0 || first.expr != nil { + t = first + break + } + } + } + // The result is an expression's, not the column's it came from. + return exprType{typeOID: t.typeOID, expr: t.expr, nullable: nullable}, nil } -// typeFirstOf types a set of alternative results, taking the first one that has -// a type. The result is nullable when any alternative is, or when the caller -// says the set is not exhaustive. +// typeFirstOf types a set of alternative results, as the type they combine +// to, which without a dialect's rules is the first typed one's. The result +// is nullable when any alternative is, or when the caller says the set is +// not exhaustive. func (a *analyzer) typeFirstOf(nodes []ast.Node, nullable bool) (exprType, error) { - var out exprType - found := false + types := make([]exprType, 0, len(nodes)) for _, n := range nodes { t, err := a.typeExpr(n) if err != nil { return exprType{}, err } - if !found && (t.typeOID != 0 || t.expr != nil) { - out = t - found = true - } + types = append(types, t) nullable = nullable || t.nullable } + out := a.commonType(types) out.nullable = nullable return out, nil } diff --git a/internal/core/analyzer/setop.go b/internal/core/analyzer/setop.go index a77b6b2944..04e8060414 100644 --- a/internal/core/analyzer/setop.go +++ b/internal/core/analyzer/setop.go @@ -27,7 +27,7 @@ func (a *analyzer) combineColumns(rules *core.SetOperationRules, op ast.SetOpera case ast.Except: col.NotNull = l.NotNull } - t := a.combineTypes(rules, l, r) + t := a.combineTypes(rules, columnExprType(l), columnExprType(r)) t.nullable = !col.NotNull col.TypeOID = t.typeOID col.DataType, col.IsArray = a.typeNameOf(t) @@ -40,17 +40,17 @@ func (a *analyzer) combineColumns(rules *core.SetOperationRules, op ast.SetOpera // combineTypes is the type a column takes from two branches: the one of // higher precedence, varying when either branch varies, with the length or // precision that holds both. -func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r core.Column) exprType { - lt, rt := a.exprOf(columnExprType(l)), a.exprOf(columnExprType(r)) +func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r exprType) exprType { + lt, rt := a.exprOf(l), a.exprOf(r) switch { case lt == nil: - return columnExprType(r) + return r case rt == nil: - return columnExprType(l) + return l } li, ri := slices.Index(rules.Precedence, lt.Name), slices.Index(rules.Precedence, rt.Name) if li < 0 || ri < 0 { - return columnExprType(l) + return l } winner, loser := lt, rt if ri < li { @@ -69,6 +69,32 @@ func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r core.Column) return a.lookupType(out) } +// commonType is the type a dialect gives an expression that yields one of +// several values, as CASE, COALESCE and GREATEST do, by the rules it +// combines a set operation's branches by; a dialect without them takes the +// first typed value's. The result is no one column's. +func (a *analyzer) commonType(types []exprType) exprType { + var out exprType + rules := a.cat.SetOperations() + for i, t := range types { + if t.typeOID == 0 && t.expr == nil { + continue + } + switch { + case out.typeOID == 0 && out.expr == nil: + out = t + case rules == nil: + return out + default: + out = a.combineTypes(rules, out, t) + } + if i > 0 { + out.sourceClassOID, out.sourceAttributeOID, out.sourceTableAlias = 0, 0, "" + } + } + return out +} + func mapValues(m map[string]string) []string { out := make([]string, 0, len(m)) for _, v := range m { diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json b/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql b/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql new file mode 100644 index 0000000000..09290a7263 --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: Combined :many +SELECT GREATEST(i, d52) AS greatest_of, + LEAST(d52, i, si) AS least_of, + CHOOSE(@pick, i, d102) AS chosen, + CASE WHEN i > 0 THEN si ELSE d102 END AS case_of, + IIF(i > 0, v20, n10) AS iif_of, + COALESCE(m, d102) AS coalesce_of, + ISNULL(i, d52) AS isnull_int, + ISNULL(n10, c3) AS isnull_text +FROM t; diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql b/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql new file mode 100644 index 0000000000..df06bb301b --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (i INT NOT NULL, d52 DECIMAL(5,2) NOT NULL, d102 DECIMAL(10,2), v20 VARCHAR(20) NOT NULL, n10 NVARCHAR(10), c3 CHAR(3), si SMALLINT NOT NULL, m MONEY); diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json b/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json new file mode 100644 index 0000000000..36ac64c6cf --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json @@ -0,0 +1,122 @@ +[ + { + "name": "Combined", + "cmd": ":many", + "columns": [ + { + "name": "greatest_of", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "least_of", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "chosen", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "case_of", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "iif_of", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "coalesce_of", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + }, + { + "name": "isnull_int", + "type": { + "name": "int" + } + }, + { + "name": "isnull_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pick", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 082d542687..9817c6286c 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -834,15 +834,9 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.ParenthesisExpression: return c.convertScalarExpression(e.Expression) case *tsql.FunctionCall: - // ISNULL(a, b) is typed as COALESCE is: the first argument's type, - // NULL only when both are. - if identifierValue(e.FunctionName) == "isnull" && len(e.Parameters) == 2 && e.OverClause == nil { - return &ast.CoalesceExpr{ - Args: &ast.List{Items: []ast.Node{ - c.convertScalarExpression(e.Parameters[0]), - c.convertScalarExpression(e.Parameters[1]), - }}, - Location: c.loc(e), + if e.OverClause == nil { + if out := c.convertAlternatives(e); out != nil { + return out } } return c.convertFunctionCall(e) @@ -1024,6 +1018,41 @@ func (c *cc) parseCall(value, culture tsql.ScalarExpression, dataType tsql.DataT return &ast.TypeCast{Arg: arg, TypeName: tn, Location: c.loc(n)} } +// convertAlternatives converts the functions that yield one of their +// arguments, which SQL Server types as the type their candidates combine +// to, as it does CASE: GREATEST and LEAST, and CHOOSE, which is the CASE +// over its index it is defined as. ISNULL, NULL only when both arguments +// are, as COALESCE is, keeps its first argument's type. +func (c *cc) convertAlternatives(e *tsql.FunctionCall) ast.Node { + args := &ast.List{} + for _, p := range e.Parameters { + args.Items = append(args.Items, c.convertScalarExpression(p)) + } + switch identifierValue(e.FunctionName) { + case "isnull": + if len(args.Items) == 2 { + return &ast.CoalesceExpr{Args: args, FirstArgType: true, Location: c.loc(e)} + } + case "greatest": + return &ast.MinMaxExpr{Op: 0, Args: args, Location: c.loc(e)} + case "least": + return &ast.MinMaxExpr{Op: 1, Args: args, Location: c.loc(e)} + case "choose": + if len(args.Items) < 2 { + return nil + } + choose := &ast.CaseExpr{Arg: args.Items[0], Args: &ast.List{}, Location: c.loc(e)} + for i, item := range args.Items[1:] { + choose.Args.Items = append(choose.Args.Items, &ast.CaseWhen{ + Expr: &ast.A_Const{Val: &ast.Integer{Ival: int64(i + 1)}}, + Result: item, + }) + } + return choose + } + return nil +} + func binaryOperator(binaryExpressionType string) string { switch binaryExpressionType { case "Add": diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index f57e3a3919..b308791e9c 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -97,9 +97,6 @@ {"name": "trim", "args": [{"type": "varchar"}], "returns": "varchar"} {"name": "trim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} {"name": "nullif", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} -{"name": "choose", "args": [{"type": "int"}, {"type": "any"}], "returns": "$2", "nullable": true} -{"name": "greatest", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} -{"name": "least", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} {"name": "concat", "args": [{"type": "any"}, {"type": "any"}], "returns": "varchar"} {"name": "concat", "args": [{"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar"} {"name": "concat", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar"} diff --git a/internal/sql/ast/coalesce_expr.go b/internal/sql/ast/coalesce_expr.go index f51c2c5c8e..36c1defa3c 100644 --- a/internal/sql/ast/coalesce_expr.go +++ b/internal/sql/ast/coalesce_expr.go @@ -10,6 +10,9 @@ type CoalesceExpr struct { Coalescecollid Oid `json:"coalescecollid"` Args *List `json:"args,omitempty"` Location int `json:"location"` + // FirstArgType marks SQL Server's ISNULL, which takes its first + // argument's type rather than the type its arguments combine to. + FirstArgType bool `json:"first_arg_type,omitempty"` } func (n *CoalesceExpr) Pos() int { From 784fef5e00176432a24e42251c01078d76c3fe79 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:50:44 -0800 Subject: [PATCH 37/74] mssql: seed ROUND with its function argument ROUND(value, length, function) truncates rather than rounds when its third argument is not zero, but only the two-argument form was seeded, so a three-argument call matched no overload by its arguments and took the first, bigint. Each overload now has a three-argument form returning what its two-argument form does. Addresses review comment r4557025437 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_round/mssql/exec.json | 5 ++ .../testdata/analyze_round/mssql/query.sql | 7 +++ .../testdata/analyze_round/mssql/schema.sql | 6 ++ .../testdata/analyze_round/mssql/stdout.json | 60 +++++++++++++++++++ internal/engine/mssql/dialect/functions.jsonl | 9 +++ 5 files changed, 87 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_round/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_round/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_round/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_round/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_round/mssql/exec.json b/internal/endtoend/testdata/analyze_round/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_round/mssql/query.sql b/internal/endtoend/testdata/analyze_round/mssql/query.sql new file mode 100644 index 0000000000..9c348e718f --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/query.sql @@ -0,0 +1,7 @@ +-- name: Rounded :many +SELECT ROUND(price, 1) AS rounded, + ROUND(price, 1, 1) AS truncated, + ROUND(ratio, 2, 1) AS ratio_truncated, + ROUND(qty, -1, 1) AS qty_truncated, + ROUND(fee, 2, 1) AS fee_truncated +FROM prices; diff --git a/internal/endtoend/testdata/analyze_round/mssql/schema.sql b/internal/endtoend/testdata/analyze_round/mssql/schema.sql new file mode 100644 index 0000000000..f759dbea38 --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE prices ( + price DECIMAL(10,2), + ratio FLOAT, + qty INT, + fee MONEY +); diff --git a/internal/endtoend/testdata/analyze_round/mssql/stdout.json b/internal/endtoend/testdata/analyze_round/mssql/stdout.json new file mode 100644 index 0000000000..871c0961ce --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/stdout.json @@ -0,0 +1,60 @@ +[ + { + "name": "Rounded", + "cmd": ":many", + "columns": [ + { + "name": "rounded", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "truncated", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "ratio_truncated", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "qty_truncated", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "fee_truncated", + "type": { + "name": "money", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index b308791e9c..97328d4296 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -194,6 +194,15 @@ {"name": "round", "args": [{"type": "smallmoney"}, {"type": "int"}], "returns": "money", "nullable": true} {"name": "round", "args": [{"type": "float"}, {"type": "int"}], "returns": "float", "nullable": true} {"name": "round", "args": [{"type": "real"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "bigint"}, {"type": "int"}, {"type": "int"}], "returns": "bigint", "nullable": true} +{"name": "round", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "smallint"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "tinyint"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "decimal"}, {"type": "int"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "round", "args": [{"type": "money"}, {"type": "int"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "smallmoney"}, {"type": "int"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "float"}, {"type": "int"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "real"}, {"type": "int"}, {"type": "int"}], "returns": "float", "nullable": true} {"name": "power", "args": [{"type": "bigint"}, {"type": "any"}], "returns": "bigint", "nullable": true} {"name": "power", "args": [{"type": "int"}, {"type": "any"}], "returns": "int", "nullable": true} {"name": "power", "args": [{"type": "smallint"}, {"type": "any"}], "returns": "int", "nullable": true} From a99032c36c8b63cb810b9a8c70f703fbcccbcd3c Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:52:00 -0800 Subject: [PATCH 38/74] mssql: type DATEADD and DATETRUNC over a string date DATEADD and DATETRUNC return the type of the date they are given, which a string literal is not: SQL Server reads one as datetime for DATEADD and datetime2(7) for DATETRUNC. The seed returned the argument's own type, varchar. String overloads now return what the server does, while a typed date keeps its type. Addresses review comment r4557025498 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_datepart/mssql/query.sql | 5 +++ .../analyze_datepart/mssql/stdout.json | 33 +++++++++++++++++++ internal/engine/mssql/dialect/functions.jsonl | 4 +++ 3 files changed, 42 insertions(+) diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql index 0c79e36fa1..f1ae69121d 100644 --- a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql @@ -6,3 +6,8 @@ SELECT id, DATENAME(weekday, created) AS weekday_of FROM authors WHERE created > DATEADD(day, @days, SYSUTCDATETIME()); + +-- name: FromStrings :one +SELECT DATEADD(day, 1, '2026-01-01') AS next_day, + DATEADD(day, 1, N'2026-01-01') AS next_day_n, + DATETRUNC(month, '2026-01-15') AS month_start; diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json index aa394695d9..6e1436e784 100644 --- a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json @@ -60,5 +60,38 @@ } } ] + }, + { + "name": "FromStrings", + "cmd": ":one", + "columns": [ + { + "name": "next_day", + "type": { + "name": "datetime", + "nullable": true + } + }, + { + "name": "next_day_n", + "type": { + "name": "datetime", + "nullable": true + } + }, + { + "name": "month_start", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [] } ] diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 97328d4296..ef53a65087 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -235,11 +235,15 @@ {"name": "switchoffset", "args": [{"type": "datetimeoffset"}, {"type": "any"}], "returns": "$1", "nullable": true} {"name": "todatetimeoffset", "args": [{"type": "any"}, {"type": "any"}], "returns": "datetimeoffset", "nullable": true} {"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "varchar"}], "returns": "datetime", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "nvarchar"}], "returns": "datetime", "nullable": true} {"name": "datediff", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} {"name": "datediff_big", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "bigint", "nullable": true} {"name": "datepart", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "int", "nullable": true} {"name": "datename", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "nvarchar(30)", "nullable": true} {"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "$2", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "datetime2(7)", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "nvarchar"}], "returns": "datetime2(7)", "nullable": true} {"name": "isjson", "args": [{"type": "any"}], "returns": "int", "nullable": true} {"name": "isjson", "args": [{"type": "any"}, {"type": "varchar"}], "returns": "int", "nullable": true} {"name": "json_value", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} From 637b47c90cf0af5590262bba7661f6888e90b736 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:52:55 -0800 Subject: [PATCH 39/74] mssql: report an unsupported query named in a block comment A named query on a statement sqlc cannot analyze is reported rather than dropped, but the check only recognized a -- name: comment, so a MERGE named with /* name: Foo :exec */, which sqlc also reads, was still dropped silently. Both comment styles are now recognized. Addresses review comment r4557025570 on #1. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../mssql/exec.json | 1 + .../mssql/query.sql | 7 +++++++ .../mssql/schema.sql | 12 ++++++++++++ .../mssql/sqlc.yaml | 10 ++++++++++ .../mssql/stderr.txt | 2 ++ internal/engine/mssql/parse.go | 5 +++-- 6 files changed, 35 insertions(+), 2 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml create mode 100644 internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql new file mode 100644 index 0000000000..a4c10b1c8b --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql @@ -0,0 +1,7 @@ +/* name: ListAuthors :many */ +SELECT id, name FROM authors; + +/* name: DeleteAll :exec */ +MERGE authors AS t +USING (SELECT @id AS id) s ON t.id = s.id +WHEN MATCHED THEN DELETE; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql new file mode 100644 index 0000000000..00557ccd53 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql @@ -0,0 +1,12 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); + +CREATE PROCEDURE list_authors AS SELECT id, name FROM authors; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt new file mode 100644 index 0000000000..531a736e9f --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:1: Merge statements are not supported diff --git a/internal/engine/mssql/parse.go b/internal/engine/mssql/parse.go index 6007003e97..be878a43ca 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -79,8 +79,9 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { return stmts, nil } -// namedQuery matches the comment that names a query. -var namedQuery = regexp.MustCompile(`(?m)^\s*--\s*name:\s*\S+`) +// namedQuery matches the comment that names a query, in either comment +// style. +var namedQuery = regexp.MustCompile(`(?m)^\s*(--|/\*)\s*name:\s*\S+`) // byteOffsets returns a function mapping a UTF-16 code-unit offset — how // teesql records source spans, mirroring ScriptDom — to a byte offset in From 6b38d72229746a5d53ae134a5547a165549ed4cb Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:54:49 -0800 Subject: [PATCH 40/74] mssql: keep the placeholder in TOP (@n) PERCENT TOP n PERCENT was skipped as no row count, which dropped a placeholder in it from the query's parameters, so the generated code did not pass it and the query failed with an undeclared variable. The percentage is now analyzed as the float SQL Server takes it as. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_paging/mssql/query.sql | 3 ++ .../testdata/analyze_paging/mssql/stdout.json | 36 +++++++++++++++++++ internal/engine/mssql/convert.go | 8 +++-- 3 files changed, 45 insertions(+), 2 deletions(-) diff --git a/internal/endtoend/testdata/analyze_paging/mssql/query.sql b/internal/endtoend/testdata/analyze_paging/mssql/query.sql index cb73b7f734..9caa757d82 100644 --- a/internal/endtoend/testdata/analyze_paging/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_paging/mssql/query.sql @@ -3,3 +3,6 @@ SELECT TOP (@n) id, name FROM authors ORDER BY id; -- name: PageAuthors :many SELECT id, name FROM authors ORDER BY id OFFSET @skip ROWS FETCH NEXT @take ROWS ONLY; + +-- name: TopPercent :many +SELECT TOP (@pct) PERCENT id, name FROM authors ORDER BY id; diff --git a/internal/endtoend/testdata/analyze_paging/mssql/stdout.json b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json index 5fc257bcbb..6c3921721d 100644 --- a/internal/endtoend/testdata/analyze_paging/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json @@ -79,5 +79,41 @@ } } ] + }, + { + "name": "TopPercent", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pct", + "type": { + "name": "float" + } + } + } + ] } ] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 9817c6286c..e293db8155 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -271,9 +271,13 @@ func (c *cc) convertQuerySpecification(n *tsql.QuerySpecification) *ast.SelectSt } } - // TOP n; TOP n PERCENT does not translate to a row count. - if n.TopRowFilter != nil && !n.TopRowFilter.Percent { + // TOP n. TOP n PERCENT is no row count, but a float a placeholder for + // it is typed as. + if n.TopRowFilter != nil { stmt.LimitCount = c.convertScalarExpression(n.TopRowFilter.Expression) + if n.TopRowFilter.Percent { + stmt.LimitCount = &ast.TypeCast{Arg: stmt.LimitCount, TypeName: &ast.TypeName{Name: "float"}} + } } if n.UniqueRowFilter == "Distinct" { From fb5722d0ca6c672b0bf4d1444db1cefa1b44806b Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:56:23 -0800 Subject: [PATCH 41/74] mssql: keep the placeholders of FOR SYSTEM_TIME A table read FOR SYSTEM_TIME AS OF @t, BETWEEN, FROM ... TO or CONTAINED IN converted to the plain table, dropping the placeholders the clause holds, so the generated code did not pass them. The table reference has nowhere to hold an expression, so the times are now analyzed with the query's WHERE clause, as the datetime2 SQL Server takes them as. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../testdata/analyze_temporal/mssql/exec.json | 5 + .../testdata/analyze_temporal/mssql/query.sql | 5 + .../analyze_temporal/mssql/schema.sql | 7 + .../analyze_temporal/mssql/stdout.json | 138 ++++++++++++++++++ internal/engine/mssql/convert.go | 34 +++++ 5 files changed, 189 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_temporal/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_temporal/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_temporal/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_temporal/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/exec.json b/internal/endtoend/testdata/analyze_temporal/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/query.sql b/internal/endtoend/testdata/analyze_temporal/mssql/query.sql new file mode 100644 index 0000000000..06320c8b79 --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: PriceAsOf :many +SELECT id, amount FROM prices FOR SYSTEM_TIME AS OF @at WHERE id = @id; + +-- name: PriceHistory :many +SELECT id, amount, valid_from, valid_to FROM prices FOR SYSTEM_TIME BETWEEN @from AND @to; diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql b/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql new file mode 100644 index 0000000000..971a5a65cd --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE prices ( + id INT PRIMARY KEY, + amount DECIMAL(10,2) NOT NULL, + valid_from DATETIME2 GENERATED ALWAYS AS ROW START NOT NULL, + valid_to DATETIME2 GENERATED ALWAYS AS ROW END NOT NULL, + PERIOD FOR SYSTEM_TIME (valid_from, valid_to) +) WITH (SYSTEM_VERSIONING = ON); diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json b/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json new file mode 100644 index 0000000000..942935336f --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json @@ -0,0 +1,138 @@ +[ + { + "name": "PriceAsOf", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "prices" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "at", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + }, + { + "number": 2, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + } + } + ] + }, + { + "name": "PriceHistory", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "prices" + }, + { + "name": "valid_from", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + }, + "table": "prices" + }, + { + "name": "valid_to", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + }, + "table": "prices" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "from", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + }, + { + "number": 2, + "column": { + "name": "to", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index e293db8155..d7b128e5ac 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -18,6 +18,10 @@ type cc struct { // toByte maps a teesql UTF-16 code-unit offset to a byte offset in the // source, so Location fields agree with StmtLocation/StmtLen. toByte func(int) int + // fromExprs are expressions a FROM item holds that the AST has no place + // for, as FOR SYSTEM_TIME AS OF @t does, analyzed with the query's WHERE + // clause so a placeholder in them is still a parameter. + fromExprs []ast.Node } // loc returns a node's start offset in bytes, for the Location fields of the @@ -233,16 +237,26 @@ func (c *cc) convertQuerySpecification(n *tsql.QuerySpecification) *ast.SelectSt } } + outerFromExprs := c.fromExprs + c.fromExprs = nil if n.FromClause != nil { stmt.FromClause = &ast.List{} for _, ref := range n.FromClause.TableReferences { stmt.FromClause.Items = append(stmt.FromClause.Items, c.convertTableReference(ref)) } } + fromExprs := c.fromExprs + c.fromExprs = outerFromExprs if n.WhereClause != nil { stmt.WhereClause = c.convertBooleanExpression(n.WhereClause.SearchCondition) } + if len(fromExprs) > 0 { + if stmt.WhereClause != nil { + fromExprs = append([]ast.Node{stmt.WhereClause}, fromExprs...) + } + stmt.WhereClause = &ast.BoolExpr{Boolop: ast.BoolExprTypeAnd, Args: &ast.List{Items: fromExprs}} + } if n.GroupByClause != nil { stmt.GroupClause = &ast.List{} @@ -416,6 +430,14 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { alias := identifierValue(t.Alias) rv.Alias = &ast.Alias{Aliasname: &alias} } + // The times of FOR SYSTEM_TIME are the datetime2 SQL Server takes. + if tc := t.TemporalClause; tc != nil { + for _, e := range []tsql.ScalarExpression{tc.StartTime, tc.EndTime} { + if e != nil { + c.fromExprs = append(c.fromExprs, &ast.TypeCast{Arg: c.convertScalarExpression(e), TypeName: typeName("datetime2", 7)}) + } + } + } return rv case *tsql.QueryDerivedTable: sub := &ast.RangeSubselect{ @@ -738,6 +760,18 @@ func (c *cc) convertBooleanExpression(expr tsql.BooleanExpression) ast.Node { } case *tsql.BooleanScalarPlaceholder: return c.convertScalarExpression(e.Scalar) + case *tsql.FullTextPredicate: + // CONTAINS and FREETEXT are the predicates the dialect seeds under + // their names, over their search condition and language term. + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: identifier(e.FullTextFunctionType)}}}, + Args: &ast.List{Items: []ast.Node{c.convertScalarExpression(e.Value)}}, + Location: c.loc(e), + } + if e.LanguageTerm != nil { + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(e.LanguageTerm)) + } + return call default: return todo(expr) } From 43b8e5ca7844931ef8c37b495ec5bb66f9828dd7 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:56:49 -0800 Subject: [PATCH 42/74] mssql: keep the placeholders of CONTAINS and FREETEXT The full-text predicates were left unconverted, which dropped a placeholder for the search condition from the query's parameters, so the generated code did not pass it. They are now calls of the functions seeded under their names, whose search condition is the nvarchar(4000) SQL Server takes. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../mssql_fulltext_params/mssql/exec.json | 1 + .../mssql_fulltext_params/mssql/go/db.go | 31 ++++++++ .../mssql_fulltext_params/mssql/go/models.go | 10 +++ .../mssql/go/query.sql.go | 70 +++++++++++++++++++ .../mssql_fulltext_params/mssql/query.sql | 5 ++ .../mssql_fulltext_params/mssql/schema.sql | 1 + .../mssql_fulltext_params/mssql/sqlc.yaml | 10 +++ internal/engine/mssql/dialect/functions.jsonl | 4 ++ 8 files changed, 132 insertions(+) create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json b/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go new file mode 100644 index 0000000000..32a015b046 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go @@ -0,0 +1,10 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Book struct { + ID int32 + Title string +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go new file mode 100644 index 0000000000..cfee736040 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go @@ -0,0 +1,70 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const searchBooks = `-- name: SearchBooks :many +SELECT id, title FROM books WHERE CONTAINS(title, @query); +` + +func (q *Queries) SearchBooks(ctx context.Context, query string) ([]Book, error) { + rows, err := q.db.QueryContext(ctx, searchBooks, sql.Named("query", query)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Book + for rows.Next() { + var i Book + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const searchBooksFreeText = `-- name: SearchBooksFreeText :many +SELECT id, title FROM books WHERE FREETEXT(title, @phrase, LANGUAGE 1033) AND id > @min_id; +` + +type SearchBooksFreeTextParams struct { + Phrase string + MinID int32 +} + +func (q *Queries) SearchBooksFreeText(ctx context.Context, arg SearchBooksFreeTextParams) ([]Book, error) { + rows, err := q.db.QueryContext(ctx, searchBooksFreeText, sql.Named("phrase", arg.Phrase), sql.Named("min_id", arg.MinID)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Book + for rows.Next() { + var i Book + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql b/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql new file mode 100644 index 0000000000..66a83e8708 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: SearchBooks :many +SELECT id, title FROM books WHERE CONTAINS(title, @query); + +-- name: SearchBooksFreeText :many +SELECT id, title FROM books WHERE FREETEXT(title, @phrase, LANGUAGE 1033) AND id > @min_id; diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql b/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql new file mode 100644 index 0000000000..baa6ed3a42 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT PRIMARY KEY, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index ef53a65087..33b4af4c59 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -291,3 +291,7 @@ {"name": "@@options", "returns": "int"} {"name": "@@textsize", "returns": "int"} {"name": "@@cursor_rows", "returns": "int"} +{"name": "contains", "args": [{"type": "nvarchar(4000)"}], "returns": "bit"} +{"name": "contains", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} +{"name": "freetext", "args": [{"type": "nvarchar(4000)"}], "returns": "bit"} +{"name": "freetext", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} From c92fc3e83e2e30defce9da70cfca5ba5a0ccb081 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:57:58 -0800 Subject: [PATCH 43/74] validate: allow an INSERT whose VALUES has no FROM list Checking a :copyfrom query read the FROM list of its INSERT ... VALUES without checking it was there. PostgreSQL's converter gives VALUES an empty one, but SQL Server's leaves it nil, so any :copyfrom query on SQL Server panicked. It now reaches the generator, which reports that :copyfrom is not supported for the driver. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../mssql_copyfrom_unsupported/mssql/exec.json | 1 + .../mssql_copyfrom_unsupported/mssql/query.sql | 2 ++ .../mssql_copyfrom_unsupported/mssql/schema.sql | 1 + .../mssql_copyfrom_unsupported/mssql/sqlc.yaml | 10 ++++++++++ .../mssql_copyfrom_unsupported/mssql/stderr.txt | 2 ++ internal/sql/validate/cmd.go | 2 +- 6 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml create mode 100644 internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql new file mode 100644 index 0000000000..8d1d2a89ef --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: CopyBooks :copyfrom +INSERT INTO books (id, title) VALUES (@id, @title); diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql new file mode 100644 index 0000000000..9e32b120d1 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT NOT NULL, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt new file mode 100644 index 0000000000..3509d2bee5 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +error generating code: :copyfrom is only supported by pgx and github.com/go-sql-driver/mysql diff --git a/internal/sql/validate/cmd.go b/internal/sql/validate/cmd.go index e9d9dd03cb..0837965405 100644 --- a/internal/sql/validate/cmd.go +++ b/internal/sql/validate/cmd.go @@ -27,7 +27,7 @@ func validateCopyfrom(n ast.Node) error { if !ok { return nil } - if len(sel.FromClause.Items) > 0 { + if sel.FromClause != nil && len(sel.FromClause.Items) > 0 { return errors.New(":copyfrom is not compatible with INSERT INTO ... SELECT") } if sel.ValuesLists == nil || len(sel.ValuesLists.Items) != 1 { From 6b661b534e92de466ad1f69cc1dc479c06c140f9 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 14:59:23 -0800 Subject: [PATCH 44/74] golang: reject :execlastid for SQL Server go-mssqldb never reports a last insert ID: its LastInsertId always returns an error, so the code generated for an :execlastid query failed every time it ran. Generating one is now an error that points at the OUTPUT INSERTED clause SQL Server returns the ID with. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/reference/query-annotations.md | 3 +++ internal/codegen/golang/gen.go | 10 ++++++++++ .../mssql_execlastid_unsupported/mssql/exec.json | 1 + .../mssql_execlastid_unsupported/mssql/query.sql | 2 ++ .../mssql_execlastid_unsupported/mssql/schema.sql | 1 + .../mssql_execlastid_unsupported/mssql/sqlc.yaml | 10 ++++++++++ .../mssql_execlastid_unsupported/mssql/stderr.txt | 2 ++ 7 files changed, 29 insertions(+) create mode 100644 internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml create mode 100644 internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt diff --git a/docs/reference/query-annotations.md b/docs/reference/query-annotations.md index 4fabe05aae..57eed12d4c 100644 --- a/docs/reference/query-annotations.md +++ b/docs/reference/query-annotations.md @@ -77,6 +77,9 @@ func (q *Queries) InsertAuthor(ctx context.Context, name string) (int64, error) } ``` +SQL Server's driver reports no last insert ID, so `:execlastid` is not +supported there. Return the ID with `OUTPUT INSERTED.id` and `:one` instead. + ## `:many` The generated method will return a slice of records via diff --git a/internal/codegen/golang/gen.go b/internal/codegen/golang/gen.go index 725f5970cf..343bc123db 100644 --- a/internal/codegen/golang/gen.go +++ b/internal/codegen/golang/gen.go @@ -212,6 +212,16 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum, tctx.SQLDriver = opts.SQLDriverGoSQLDriverMySQL } + // go-mssqldb never reports a last insert ID; SQL Server returns one with + // OUTPUT INSERTED. + if req.Settings.Engine == engineMSSQL { + for _, q := range queries { + if q.Cmd == metadata.CmdExecLastId { + return nil, fmt.Errorf("query %q: :execlastid is not supported for SQL Server, whose driver reports no last insert ID; use OUTPUT INSERTED. with :one", q.MethodName) + } + } + } + if tctx.UsesBatch && !tctx.SQLDriver.IsPGX() { return nil, errors.New(":batch* commands are only supported by pgx") } diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql new file mode 100644 index 0000000000..d1caf2a305 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: CreateBook :execlastid +INSERT INTO books (id, title) VALUES (@id, @title); diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql new file mode 100644 index 0000000000..9e32b120d1 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT NOT NULL, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt new file mode 100644 index 0000000000..73b2d2edf0 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +error generating code: query "CreateBook": :execlastid is not supported for SQL Server, whose driver reports no last insert ID; use OUTPUT INSERTED. with :one From a5dfd4972f37399c90c18c42a5f124e0ecbcfbd3 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:02:25 -0800 Subject: [PATCH 45/74] mssql: support WITH on INSERT The converter dropped the WITH clause of an INSERT, and the core analyzer bound CTEs for SELECT, UPDATE and DELETE but not INSERT, so an INSERT ... SELECT reading a CTE failed with an unknown relation. Both now carry it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/dml.go | 3 + .../analyze_cte_insert/mssql/exec.json | 5 ++ .../analyze_cte_insert/mssql/query.sql | 5 ++ .../analyze_cte_insert/mssql/schema.sql | 2 + .../analyze_cte_insert/mssql/stdout.json | 67 +++++++++++++++++++ internal/engine/mssql/convert.go | 3 +- 6 files changed, 84 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json diff --git a/internal/core/analyzer/dml.go b/internal/core/analyzer/dml.go index 8b7554b638..dc16d47ceb 100644 --- a/internal/core/analyzer/dml.go +++ b/internal/core/analyzer/dml.go @@ -11,6 +11,9 @@ func (a *analyzer) analyzeInsert(s *ast.InsertStmt) error { if s.Relation == nil { return fmt.Errorf("insert: missing relation") } + if err := a.bindCTEs(s.WithClause); err != nil { + return err + } rel, err := a.bindRangeVar(s.Relation) if err != nil { return err diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json b/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql b/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql new file mode 100644 index 0000000000..b2b0e55321 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: CopyFromAuthor :many +WITH a AS (SELECT id FROM authors WHERE name = @name) +INSERT INTO books (id, author_id, title) +OUTPUT INSERTED.id, INSERTED.title +SELECT CAST(@book_id AS INT), a.id, CAST(@title AS NVARCHAR(200)) FROM a; diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql b/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql new file mode 100644 index 0000000000..ceb008432e --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE books (id INT NOT NULL, author_id INT NOT NULL, title NVARCHAR(200) NOT NULL); +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(100) NOT NULL); diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json b/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json new file mode 100644 index 0000000000..af61a35a49 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json @@ -0,0 +1,67 @@ +[ + { + "name": "CopyFromAuthor", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "books" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + }, + { + "number": 2, + "column": { + "name": "book_id", + "type": { + "name": "int" + } + } + }, + { + "number": 3, + "column": { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index d7b128e5ac..8f01ac752e 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1253,7 +1253,8 @@ func (c *cc) convertInsertStatement(n *tsql.InsertStatement) ast.Node { } stmt := &ast.InsertStmt{ - Relation: c.parseRangeVar(target.SchemaObject), + Relation: c.parseRangeVar(target.SchemaObject), + WithClause: c.convertWithClause(n.WithCtesAndXmlNamespaces), } if len(spec.Columns) > 0 { From e8c00575623a1fb9eebb59fd0b7cd067a6c9d57d Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:04:19 -0800 Subject: [PATCH 46/74] mssql: apply ALTER TABLE ALTER COLUMN ALTER COLUMN was ignored, so a column kept the type and nullability it was created with. It now converts to the column type and NOT NULL changes the core already applies: a new type with NOT NULL keeps the column NOT NULL, and one without makes it nullable, as SQL Server does. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_alter_column/mssql/exec.json | 5 +++ .../analyze_alter_column/mssql/query.sql | 2 + .../analyze_alter_column/mssql/schema.sql | 10 +++++ .../analyze_alter_column/mssql/stdout.json | 43 +++++++++++++++++++ internal/engine/mssql/convert.go | 34 +++++++++++++++ 5 files changed, 94 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_alter_column/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_alter_column/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_alter_column/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_alter_column/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_alter_column/mssql/exec.json b/internal/endtoend/testdata/analyze_alter_column/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_alter_column/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_alter_column/mssql/query.sql b/internal/endtoend/testdata/analyze_alter_column/mssql/query.sql new file mode 100644 index 0000000000..59200e3a6f --- /dev/null +++ b/internal/endtoend/testdata/analyze_alter_column/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: ListItems :many +SELECT * FROM items; diff --git a/internal/endtoend/testdata/analyze_alter_column/mssql/schema.sql b/internal/endtoend/testdata/analyze_alter_column/mssql/schema.sql new file mode 100644 index 0000000000..8cee83fbc9 --- /dev/null +++ b/internal/endtoend/testdata/analyze_alter_column/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE items ( + id INT NOT NULL, + code INT NOT NULL, + label VARCHAR(10) NOT NULL, + note INT NULL +); + +ALTER TABLE items ALTER COLUMN code BIGINT; +ALTER TABLE items ALTER COLUMN label NVARCHAR(50) NOT NULL; +ALTER TABLE items ALTER COLUMN note INT NOT NULL; diff --git a/internal/endtoend/testdata/analyze_alter_column/mssql/stdout.json b/internal/endtoend/testdata/analyze_alter_column/mssql/stdout.json new file mode 100644 index 0000000000..d9e42a7d12 --- /dev/null +++ b/internal/endtoend/testdata/analyze_alter_column/mssql/stdout.json @@ -0,0 +1,43 @@ +[ + { + "name": "ListItems", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + }, + { + "name": "code", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "items" + }, + { + "name": "label", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 50 + } + ] + }, + "table": "items" + }, + { + "name": "note", + "type": { + "name": "int" + }, + "table": "items" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 8f01ac752e..a9b7fa6a07 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -68,6 +68,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertAlterTableAddTableElementStatement(n) case *tsql.AlterTableDropTableElementStatement: return c.convertAlterTableDropTableElementStatement(n) + case *tsql.AlterTableAlterColumnStatement: + return c.convertAlterTableAlterColumnStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1670,6 +1672,38 @@ func (c *cc) convertAlterTableAddTableElementStatement(n *tsql.AlterTableAddTabl return stmt } +// convertAlterTableAlterColumnStatement converts ALTER COLUMN, which gives a +// column a new type and makes it nullable unless it says NOT NULL, or only +// sets whether it is nullable. +func (c *cc) convertAlterTableAlterColumnStatement(n *tsql.AlterTableAlterColumnStatement) ast.Node { + if n.SchemaObjectName == nil || n.ColumnIdentifier == nil { + return todo(n) + } + name := identifierValue(n.ColumnIdentifier) + stmt := &ast.AlterTableStmt{ + Table: parseTableName(n.SchemaObjectName), + Cmds: &ast.List{}, + } + notNull := n.AlterTableAlterColumnOption == "NotNull" + if n.DataType != nil { + stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{ + Name: &name, + Subtype: ast.AT_AlterColumnType, + Def: &ast.ColumnDef{Colname: name, TypeName: dataTypeName(n.DataType), IsNotNull: notNull}, + }) + } + switch { + case notNull: + stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{Name: &name, Subtype: ast.AT_SetNotNull}) + case n.DataType != nil || n.AlterTableAlterColumnOption == "Null": + stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{Name: &name, Subtype: ast.AT_DropNotNull}) + } + if len(stmt.Cmds.Items) == 0 { + return todo(n) + } + return stmt +} + func (c *cc) convertAlterTableDropTableElementStatement(n *tsql.AlterTableDropTableElementStatement) ast.Node { if n.SchemaObjectName == nil { return todo(n) From 2f48b4b15778bfb0679759188fe56229c3d10e30 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:06:06 -0800 Subject: [PATCH 47/74] mssql: apply sp_rename to tables and columns SQL Server renames a table or column with EXEC sp_rename, which was ignored as a procedure call, so a schema kept the old names. A call of sp_rename, its arguments by position or by name, now converts to the table or column rename the core already applies. Any other procedure call is still no statement sqlc has a use for. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_sp_rename/mssql/exec.json | 5 + .../analyze_sp_rename/mssql/query.sql | 8 ++ .../analyze_sp_rename/mssql/schema.sql | 15 +++ .../analyze_sp_rename/mssql/stdout.json | 58 ++++++++++++ internal/engine/mssql/convert.go | 91 +++++++++++++++++++ 5 files changed, 177 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_sp_rename/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_sp_rename/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_sp_rename/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_sp_rename/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_sp_rename/mssql/exec.json b/internal/endtoend/testdata/analyze_sp_rename/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_sp_rename/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_sp_rename/mssql/query.sql b/internal/endtoend/testdata/analyze_sp_rename/mssql/query.sql new file mode 100644 index 0000000000..221a0e21da --- /dev/null +++ b/internal/endtoend/testdata/analyze_sp_rename/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: RenamedColumn :many +SELECT id, w FROM t; + +-- name: RenamedTable :many +SELECT id FROM renamed; + +-- name: RenamedInSchema :many +SELECT b FROM s.y; diff --git a/internal/endtoend/testdata/analyze_sp_rename/mssql/schema.sql b/internal/endtoend/testdata/analyze_sp_rename/mssql/schema.sql new file mode 100644 index 0000000000..1fd58b17e8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_sp_rename/mssql/schema.sql @@ -0,0 +1,15 @@ +CREATE TABLE t (id INT NOT NULL, v NVARCHAR(10)); +CREATE TABLE [old name] (id INT NOT NULL); +GO +EXEC sp_rename 't.v', 'w', 'COLUMN'; +GO +EXEC sp_rename @objname = N'dbo.[old name]', @newname = 'renamed'; +GO +CREATE SCHEMA s; +GO +CREATE TABLE s.x (a INT); +GO +EXEC sp_rename 's.x.a', 'b', 'COLUMN'; +GO +EXEC sp_rename 's.x', 'y'; +GO diff --git a/internal/endtoend/testdata/analyze_sp_rename/mssql/stdout.json b/internal/endtoend/testdata/analyze_sp_rename/mssql/stdout.json new file mode 100644 index 0000000000..89f1fe60c6 --- /dev/null +++ b/internal/endtoend/testdata/analyze_sp_rename/mssql/stdout.json @@ -0,0 +1,58 @@ +[ + { + "name": "RenamedColumn", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "t" + }, + { + "name": "w", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + }, + "table": "t" + } + ], + "params": [] + }, + { + "name": "RenamedTable", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "renamed" + } + ], + "params": [] + }, + { + "name": "RenamedInSchema", + "cmd": ":many", + "columns": [ + { + "name": "b", + "type": { + "name": "int", + "nullable": true + }, + "table": "y" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index a9b7fa6a07..7e88f4fb54 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -70,6 +70,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertAlterTableDropTableElementStatement(n) case *tsql.AlterTableAlterColumnStatement: return c.convertAlterTableAlterColumnStatement(n) + case *tsql.ExecuteStatement: + return c.convertExecuteStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1672,6 +1674,95 @@ func (c *cc) convertAlterTableAddTableElementStatement(n *tsql.AlterTableAddTabl return stmt } +// convertExecuteStatement converts the one procedure call a schema changes +// the catalog with: sp_rename, of a table, or of a column when its object +// type is COLUMN. Any other call is no statement sqlc has a use for. +func (c *cc) convertExecuteStatement(n *tsql.ExecuteStatement) ast.Node { + spec := n.ExecuteSpecification + if spec == nil { + return todo(n) + } + proc, ok := spec.ExecutableEntity.(*tsql.ExecutableProcedureReference) + if !ok || proc.ProcedureReference == nil || proc.ProcedureReference.ProcedureReference == nil { + return todo(n) + } + if name := proc.ProcedureReference.ProcedureReference.Name; name == nil || identifierValue(name.BaseIdentifier) != "sp_rename" { + return todo(n) + } + // Arguments are passed by position or by name. + args := map[string]string{} + for i, p := range proc.Parameters { + lit, ok := p.ParameterValue.(*tsql.StringLiteral) + if !ok { + return todo(n) + } + key := []string{"objname", "newname", "objtype"}[min(i, 2)] + if p.Variable != nil { + key = strings.ToLower(strings.TrimPrefix(p.Variable.Name, "@")) + } + args[key] = lit.Value + } + parts := splitObjectName(args["objname"]) + newName := identifier(args["newname"]) + if len(parts) == 0 || newName == "" { + return todo(n) + } + table := func(parts []string) *ast.TableName { + tn := &ast.TableName{Name: parts[len(parts)-1]} + if len(parts) > 1 && parts[len(parts)-2] != "dbo" { + tn.Schema = parts[len(parts)-2] + } + return tn + } + switch strings.ToLower(args["objtype"]) { + case "column": + if len(parts) < 2 { + return todo(n) + } + col := parts[len(parts)-1] + return &ast.RenameColumnStmt{ + Table: table(parts[:len(parts)-1]), + Col: &ast.ColumnRef{Name: col}, + NewName: &newName, + } + case "", "object": + return &ast.RenameTableStmt{Table: table(parts), NewName: &newName} + } + return todo(n) +} + +// splitObjectName splits a name sp_rename takes, such as dbo.[my table].c, +// into its lowercased parts, unquoting bracketed and double-quoted ones. +func splitObjectName(s string) []string { + var parts []string + var cur strings.Builder + for i := 0; i < len(s); i++ { + switch ch := s[i]; { + case ch == '[' || ch == '"': + end := byte(']') + if ch == '"' { + end = '"' + } + for i++; i < len(s); i++ { + if s[i] == end { + if i+1 < len(s) && s[i+1] == end { + i++ + } else { + break + } + } + cur.WriteByte(s[i]) + } + case ch == '.': + parts = append(parts, identifier(cur.String())) + cur.Reset() + default: + cur.WriteByte(ch) + } + } + return append(parts, identifier(cur.String())) +} + // convertAlterTableAlterColumnStatement converts ALTER COLUMN, which gives a // column a new type and makes it nullable unless it says NOT NULL, or only // sets whether it is nullable. From d866aba959aef3debff924cb1e29471f4ced5d3f Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:08:34 -0800 Subject: [PATCH 48/74] mssql: apply the schema changes in IF and BEGIN ... END blocks A migration script guards its changes, as IF OBJECT_ID('t') IS NULL CREATE TABLE t ... does, and a statement inside an IF or BEGIN ... END block was skipped with the block, so such a schema was empty. The schema changes in a block's THEN branch are now applied, each tolerating the object being there or not, since the guard decides that: a create of one that exists, and a drop, alter or rename of one that does not, are skipped. Queries and data changes inside a block are still left out. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_guarded_ddl/mssql/exec.json | 5 ++ .../analyze_guarded_ddl/mssql/query.sql | 5 ++ .../analyze_guarded_ddl/mssql/schema.sql | 16 +++++ .../analyze_guarded_ddl/mssql/stdout.json | 61 +++++++++++++++++++ internal/engine/mssql/convert.go | 47 ++++++++++++++ internal/engine/mssql/parse.go | 5 ++ 6 files changed, 139 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_guarded_ddl/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_guarded_ddl/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_guarded_ddl/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_guarded_ddl/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_guarded_ddl/mssql/exec.json b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_guarded_ddl/mssql/query.sql b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/query.sql new file mode 100644 index 0000000000..e833cf85e7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: AuthorBooks :many +SELECT a.name, b.title FROM authors a JOIN books b ON b.author_id = a.id; + +-- name: BookTitles :many +SELECT * FROM book_titles; diff --git a/internal/endtoend/testdata/analyze_guarded_ddl/mssql/schema.sql b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/schema.sql new file mode 100644 index 0000000000..b2baec1615 --- /dev/null +++ b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/schema.sql @@ -0,0 +1,16 @@ +IF OBJECT_ID('dbo.authors', 'U') IS NULL + CREATE TABLE authors (id INT NOT NULL PRIMARY KEY, name NVARCHAR(100) NOT NULL); +GO +IF NOT EXISTS (SELECT 1 FROM sys.tables WHERE name = 'books') +BEGIN + CREATE TABLE books (id INT NOT NULL, author_id INT NOT NULL); + INSERT INTO books (id, author_id) VALUES (1, 1); +END +GO +IF COL_LENGTH('dbo.books', 'title') IS NULL + ALTER TABLE books ADD title NVARCHAR(200) NULL; +GO +IF OBJECT_ID('dbo.book_titles', 'V') IS NOT NULL + DROP VIEW book_titles; +GO +CREATE VIEW book_titles AS SELECT id, title FROM books; diff --git a/internal/endtoend/testdata/analyze_guarded_ddl/mssql/stdout.json b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/stdout.json new file mode 100644 index 0000000000..5ee2a3ab9a --- /dev/null +++ b/internal/endtoend/testdata/analyze_guarded_ddl/mssql/stdout.json @@ -0,0 +1,61 @@ +[ + { + "name": "AuthorBooks", + "cmd": ":many", + "columns": [ + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [] + }, + { + "name": "BookTitles", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "book_titles" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "book_titles" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 7e88f4fb54..81de07741b 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1674,6 +1674,53 @@ func (c *cc) convertAlterTableAddTableElementStatement(n *tsql.AlterTableAddTabl return stmt } +// blockSchemaStatements are the schema changes an IF or BEGIN ... END block +// makes, as a migration script guards CREATE TABLE with IF OBJECT_ID(...) +// IS NULL. The THEN branch is taken, and since a guard is what decides +// whether a change applies, each change tolerates the object being there +// or not: a create of one that exists and a drop or alter of one that does +// not are skipped. Anything that is not a schema change is left out, as it +// is outside a block. +func (c *cc) blockSchemaStatements(n tsql.Statement) []ast.Node { + var out []ast.Node + switch s := n.(type) { + case *tsql.IfStatement: + out = c.blockSchemaStatements(s.ThenStatement) + case *tsql.BeginEndBlockStatement: + if s.StatementList != nil { + for _, inner := range s.StatementList.Statements { + out = append(out, c.blockSchemaStatements(inner)...) + } + } + case nil: + default: + switch stmt := c.convert(s).(type) { + case *ast.TODO, *ast.SelectStmt, *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt: + case *ast.CreateTableStmt: + stmt.IfNotExists = true + out = append(out, stmt) + case *ast.DropTableStmt: + stmt.IfExists = true + out = append(out, stmt) + case *ast.AlterTableStmt: + stmt.MissingOk = true + out = append(out, stmt) + case *ast.RenameColumnStmt: + stmt.MissingOk = true + out = append(out, stmt) + case *ast.RenameTableStmt: + stmt.MissingOk = true + out = append(out, stmt) + case *ast.ViewStmt: + stmt.Replace = true + out = append(out, stmt) + default: + out = append(out, stmt) + } + } + return out +} + // convertExecuteStatement converts the one procedure call a schema changes // the catalog with: sp_rename, of a table, or of a column when its object // type is COLUMN. Any other call is no statement sqlc has a use for. diff --git a/internal/engine/mssql/parse.go b/internal/engine/mssql/parse.go index be878a43ca..174e120c19 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -61,6 +61,11 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { Location: start, } } + for _, ddl := range converter.blockSchemaStatements(stmt) { + stmts = append(stmts, ast.Statement{ + Raw: &ast.RawStmt{Stmt: ddl, StmtLocation: loc, StmtLen: end - loc}, + }) + } loc = end continue } From 26bfd8a3b68cd562cebbebee7812f080e310dde1 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:10:21 -0800 Subject: [PATCH 49/74] mssql: type NEXT VALUE FOR a sequence CREATE SEQUENCE was ignored, so NEXT VALUE FOR could not be typed and the query failed. A sequence is now recorded as a function returning its type, bigint unless AS names another, which NEXT VALUE FOR calls. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_sequences/mssql/exec.json | 5 ++ .../analyze_sequences/mssql/query.sql | 5 ++ .../analyze_sequences/mssql/schema.sql | 7 +++ .../analyze_sequences/mssql/stdout.json | 52 +++++++++++++++++++ internal/engine/mssql/convert.go | 37 +++++++++++++ 5 files changed, 106 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_sequences/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_sequences/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_sequences/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_sequences/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_sequences/mssql/exec.json b/internal/endtoend/testdata/analyze_sequences/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_sequences/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_sequences/mssql/query.sql b/internal/endtoend/testdata/analyze_sequences/mssql/query.sql new file mode 100644 index 0000000000..4deeb26510 --- /dev/null +++ b/internal/endtoend/testdata/analyze_sequences/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: NextIDs :one +SELECT NEXT VALUE FOR order_seq AS a, NEXT VALUE FOR dbo.small_seq AS b, NEXT VALUE FOR billing.invoice_seq AS c; + +-- name: InsertOrder :exec +INSERT INTO orders (id, n) VALUES (NEXT VALUE FOR order_seq, @n); diff --git a/internal/endtoend/testdata/analyze_sequences/mssql/schema.sql b/internal/endtoend/testdata/analyze_sequences/mssql/schema.sql new file mode 100644 index 0000000000..87169d0004 --- /dev/null +++ b/internal/endtoend/testdata/analyze_sequences/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE SEQUENCE order_seq; +CREATE SEQUENCE dbo.small_seq AS INT START WITH 1; +GO +CREATE SCHEMA billing; +GO +CREATE SEQUENCE billing.invoice_seq AS DECIMAL(12, 0); +CREATE TABLE orders (id BIGINT NOT NULL, n INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_sequences/mssql/stdout.json b/internal/endtoend/testdata/analyze_sequences/mssql/stdout.json new file mode 100644 index 0000000000..f36f4234a5 --- /dev/null +++ b/internal/endtoend/testdata/analyze_sequences/mssql/stdout.json @@ -0,0 +1,52 @@ +[ + { + "name": "NextIDs", + "cmd": ":one", + "columns": [ + { + "name": "a", + "type": { + "name": "bigint" + } + }, + { + "name": "b", + "type": { + "name": "int" + } + }, + { + "name": "c", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 0 + } + ] + } + } + ], + "params": [] + }, + { + "name": "InsertOrder", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + }, + "table": "orders" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 81de07741b..d9d2ffbc29 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -72,6 +72,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertAlterTableAlterColumnStatement(n) case *tsql.ExecuteStatement: return c.convertExecuteStatement(n) + case *tsql.CreateSequenceStatement: + return c.convertCreateSequenceStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -989,6 +991,14 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { }, Location: c.loc(e), } + case *tsql.NextValueForExpression: + if e.SequenceName == nil { + return todo(e) + } + return &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: sequenceFunc(e.SequenceName)}}}, + Location: c.loc(e), + } case *tsql.GlobalVariableExpression: // @@ROWCOUNT and its relatives are typed as the functions the // dialect seeds under their names. @@ -1674,6 +1684,33 @@ func (c *cc) convertAlterTableAddTableElementStatement(n *tsql.AlterTableAddTabl return stmt } +// convertCreateSequenceStatement records a sequence as the function NEXT +// VALUE FOR it calls, under a name no function can have, returning the +// sequence's type: bigint unless it says AS another. +func (c *cc) convertCreateSequenceStatement(n *tsql.CreateSequenceStatement) ast.Node { + if n.Name == nil || n.Name.BaseIdentifier == nil { + return todo(n) + } + returns := &ast.TypeName{Name: "bigint"} + for _, opt := range n.SequenceOptions { + if dt, ok := opt.(*tsql.DataTypeSequenceOption); ok && dt.DataType != nil { + returns = dataTypeName(dt.DataType) + } + } + return &ast.CreateFunctionStmt{ + Func: &ast.FuncName{Name: sequenceFunc(n.Name)}, + ReturnType: returns, + } +} + +func sequenceFunc(name *tsql.SchemaObjectName) string { + tn := parseTableName(name) + if tn.Schema != "" { + return "next value for " + tn.Schema + "." + tn.Name + } + return "next value for " + tn.Name +} + // blockSchemaStatements are the schema changes an IF or BEGIN ... END block // makes, as a migration script guards CREATE TABLE with IF OBJECT_ID(...) // IS NULL. The THEN branch is taken, and since a guard is what decides From 937787ec208b584d3a58d1c18e93b6d8b51a92d1 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:13:31 -0800 Subject: [PATCH 50/74] mssql: type a call to a scalar function the schema creates CREATE FUNCTION was ignored, so a query calling the function failed. A scalar function is now recorded with its parameters and result, which SQL Server reports nullable whatever the arguments, so the converter returns Nullable(T) and the schema records a T that may be NULL. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/schema/schema.go | 16 ++-- .../analyze_scalar_functions/mssql/exec.json | 5 ++ .../analyze_scalar_functions/mssql/query.sql | 2 + .../analyze_scalar_functions/mssql/schema.sql | 8 ++ .../mssql/stdout.json | 82 +++++++++++++++++++ internal/engine/mssql/convert.go | 29 +++++++ 6 files changed, 137 insertions(+), 5 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index 35def91fd7..2d3e26d3da 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -562,7 +562,12 @@ func applyCreateFunction(cat *core.Catalog, stmt *ast.CreateFunctionStmt) error if stmt.Func == nil || stmt.Func.Name == "" || stmt.ReturnType == nil { return nil } - returnOID, err := cat.ResolveType(stmt.ReturnType) + // A Nullable(T) result is a T the function may return NULL for. + ret := core.TypeExprOfTypeName(stmt.ReturnType) + if ret == nil { + return fmt.Errorf("function %q: missing type name", stmt.Func.Name) + } + returnOID, err := cat.ResolveTypeExpr(ret.WithNullable(false)) if err != nil { return fmt.Errorf("function %q: %w", stmt.Func.Name, err) } @@ -589,10 +594,11 @@ func applyCreateFunction(cat *core.Catalog, stmt *ast.CreateFunctionStmt) error } } _, err = cat.CreateProc(core.ProcSpec{ - Name: stmt.Func.Name, - ReturnTypeOID: returnOID, - ReturnSet: stmt.ReturnType != nil && stmt.ReturnType.Setof, - Args: args, + Name: stmt.Func.Name, + ReturnTypeOID: returnOID, + ReturnSet: stmt.ReturnType != nil && stmt.ReturnType.Setof, + ReturnNullable: ret.Nullable, + Args: args, }) return err } diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql new file mode 100644 index 0000000000..89bb6eef73 --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: ItemTotals :many +SELECT id, dbo.f_add(id, price) AS total, dbo.f_add(@n, DEFAULT) AS d, dbo.label(@s) AS l FROM items; diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql new file mode 100644 index 0000000000..bbb242872d --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql @@ -0,0 +1,8 @@ +CREATE TABLE items (id INT NOT NULL, price DECIMAL(10,2) NOT NULL); +GO +CREATE FUNCTION dbo.f_add(@a INT, @b DECIMAL(10,2) = 1) RETURNS DECIMAL(12,2) +AS BEGIN RETURN @a + @b END; +GO +CREATE FUNCTION label(@s NVARCHAR(20)) RETURNS NVARCHAR(30) WITH SCHEMABINDING +AS BEGIN RETURN N'x' + @s END; +GO diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json new file mode 100644 index 0000000000..9da8e78da8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json @@ -0,0 +1,82 @@ +[ + { + "name": "ItemTotals", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + }, + { + "name": "total", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "d", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "l", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "s", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 20 + } + ] + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index d9d2ffbc29..71fd0bcb63 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -74,6 +74,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertExecuteStatement(n) case *tsql.CreateSequenceStatement: return c.convertCreateSequenceStatement(n) + case *tsql.CreateFunctionStatement: + return c.convertCreateFunctionStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1703,6 +1705,33 @@ func (c *cc) convertCreateSequenceStatement(n *tsql.CreateSequenceStatement) ast } } +// convertCreateFunctionStatement records a scalar function, whose result +// SQL Server reports nullable whatever its arguments are. +func (c *cc) convertCreateFunctionStatement(n *tsql.CreateFunctionStatement) ast.Node { + ret, ok := n.ReturnType.(*tsql.ScalarFunctionReturnType) + if !ok || ret.DataType == nil || n.Name == nil || n.Name.BaseIdentifier == nil { + return todo(n) + } + tn := parseTableName(n.Name) + params := &ast.List{} + for _, p := range n.Parameters { + if p.VariableName == nil || p.DataType == nil { + continue + } + name := strings.TrimPrefix(p.VariableName.Value, "@") + param := &ast.FuncParam{Name: &name, Type: dataTypeName(p.DataType)} + if p.Value != nil { + param.DefExpr = c.convertScalarExpression(p.Value) + } + params.Items = append(params.Items, param) + } + return &ast.CreateFunctionStmt{ + Func: &ast.FuncName{Schema: tn.Schema, Name: tn.Name}, + Params: params, + ReturnType: nullableTypeName(dataTypeName(ret.DataType)), + } +} + func sequenceFunc(name *tsql.SchemaObjectName) string { tn := parseTableName(name) if tn.Schema != "" { From e3e6264e2757b5aadfbe9b224cbbb21e0577d58a Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:18:11 -0800 Subject: [PATCH 51/74] mssql: select from a table-valued function the schema creates A table-valued function called in FROM was not converted, so the query failed. A function in FROM is now called, and a table-valued function returns rows of table(col type, ...): the columns a multi-statement function declares, or those an inline function's query selects, which the schema works out as it does a view's. A function returning such rows binds as a relation of those columns. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/scope.go | 21 +++ internal/core/schema/schema.go | 38 ++++ .../mssql/exec.json | 5 + .../mssql/query.sql | 8 + .../mssql/schema.sql | 11 ++ .../mssql/stdout.json | 171 ++++++++++++++++++ internal/engine/mssql/convert.go | 71 +++++++- 7 files changed, 317 insertions(+), 8 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json diff --git a/internal/core/analyzer/scope.go b/internal/core/analyzer/scope.go index 7bc1424280..b48986d383 100644 --- a/internal/core/analyzer/scope.go +++ b/internal/core/analyzer/scope.go @@ -158,12 +158,33 @@ func (a *analyzer) bindRangeFunction(rf *ast.RangeFunction) (scopeRel, error) { col.TypeOID, col.NotNull = p.ReturnTypeOID, !p.ReturnNullable } rel.cols = []core.ClassColumn{col} + if cols := a.rowColumns(overloads[0]); cols != nil { + rel.cols = cols + } if rf.Coldeflist != nil { rel.cols = a.coldefColumns(rf.Coldeflist, col) } return rel, nil } +// rowColumns are the columns of a function returning rows of +// table(col type, ...), as a SQL Server table-valued function does. +func (a *analyzer) rowColumns(p core.ProcOverload) []core.ClassColumn { + row, err := a.cat.TypeExprOf(p.ReturnTypeOID) + if err != nil || row.Name != "table" || len(row.Args) == 0 { + return nil + } + var cols []core.ClassColumn + for _, arg := range row.Args { + if arg.Label == "" || arg.Type == nil { + return nil + } + t := a.lookupType(arg.Type.WithNullable(false)) + cols = append(cols, core.ClassColumn{Name: arg.Label, TypeOID: t.typeOID, Type: t.expr, NotNull: !arg.Type.Nullable}) + } + return cols +} + // coldefColumns are the columns a function's column definition list // declares, for a function returning rows of more than one column. A // definition with no type is the function's own result. diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index 2d3e26d3da..296f2644f3 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -484,6 +484,37 @@ func applyCreateDomain(cat *core.Catalog, stmt *ast.CreateDomainStmt) error { return err } +// functionQuery is the query a function returns the rows of, which a +// converter passes as the "query" option when the function's columns are +// whatever it selects, as a SQL Server inline table-valued function's are. +func functionQuery(stmt *ast.CreateFunctionStmt) ast.Node { + for _, item := range listItems(stmt.Options) { + if def, ok := item.(*ast.DefElem); ok && def.Defname != nil && *def.Defname == "query" { + return def.Arg + } + } + return nil +} + +// queryRow is the row type of a query's results, table(col type, ...). +func queryRow(cat *core.Catalog, query ast.Node) (*core.TypeExpr, error) { + res, err := analyzer.Prepare(cat, query) + if err != nil { + return nil, err + } + row := &core.TypeExpr{Name: "table"} + for _, col := range res.Columns { + t := col.Type + if t == nil { + if t, err = cat.TypeExprOf(col.TypeOID); err != nil { + return nil, err + } + } + row.Args = append(row.Args, core.TypeArg{Label: col.Name, Type: t.WithNullable(!col.NotNull)}) + } + return row, nil +} + // applyCompositeType records a composite type as a type whose arguments are // its fields, labelled by name. func applyCompositeType(cat *core.Catalog, stmt *ast.CompositeTypeStmt) error { @@ -567,6 +598,13 @@ func applyCreateFunction(cat *core.Catalog, stmt *ast.CreateFunctionStmt) error if ret == nil { return fmt.Errorf("function %q: missing type name", stmt.Func.Name) } + if query := functionQuery(stmt); query != nil { + row, err := queryRow(cat, query) + if err != nil { + return fmt.Errorf("function %q: %w", stmt.Func.Name, err) + } + ret = row + } returnOID, err := cat.ResolveTypeExpr(ret.WithNullable(false)) if err != nil { return fmt.Errorf("function %q: %w", stmt.Func.Name, err) diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql new file mode 100644 index 0000000000..703a1aa0a2 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: ApplyBoth :many +SELECT o.id, o.name, o.price, m.id AS mid, m.label FROM dbo.items_over(@p) o CROSS APPLY dbo.ms_items(o.id) m; + +-- name: InlineStar :many +SELECT * FROM items_over(@min); + +-- name: OuterApply :many +SELECT i.id, m.label FROM items i OUTER APPLY ms_items(i.id) m WHERE i.id = @id; diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql new file mode 100644 index 0000000000..9f7b6cba9d --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE items (id INT NOT NULL, name NVARCHAR(20) NULL, price DECIMAL(10,2) NOT NULL); +GO +CREATE FUNCTION dbo.items_over(@min DECIMAL(10,2)) RETURNS TABLE +AS RETURN SELECT id, name, price FROM items WHERE price > @min; +GO +CREATE FUNCTION ms_items(@n INT) RETURNS @t TABLE (id INT NOT NULL, label NVARCHAR(30)) +AS BEGIN + INSERT @t SELECT id, name FROM items WHERE id > @n; + RETURN; +END; +GO diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json new file mode 100644 index 0000000000..f8997abd13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json @@ -0,0 +1,171 @@ +[ + { + "name": "ApplyBoth", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "price", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "mid", + "type": { + "name": "int" + } + }, + { + "name": "label", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "p", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + } + ] + }, + { + "name": "InlineStar", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "price", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + } + ] + }, + { + "name": "OuterApply", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + }, + { + "name": "label", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 71fd0bcb63..0d491d419d 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -498,6 +498,11 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { return c.convertOpenJson(t) case *tsql.GlobalFunctionTableReference: return c.convertGlobalFunctionTableReference(t) + case *tsql.SchemaObjectFunctionTableReference: + if t.SchemaObject == nil || t.SchemaObject.BaseIdentifier == nil { + return todo(t) + } + return c.rangeFunction(t, identifierValue(t.SchemaObject.BaseIdentifier), t.Parameters, t.Alias, nil) case *tsql.PivotedTableReference: return c.convertPivot(t) case *tsql.UnpivotedTableReference: @@ -603,7 +608,7 @@ func (c *cc) convertInlineDerivedTable(n *tsql.InlineDerivedTable) ast.Node { } // rangeFunction is a call in FROM to a function returning rows of the -// columns defs declares. +// columns defs declares, or of its own columns when there are none. func (c *cc) rangeFunction(n tsql.Node, name string, args []tsql.ScalarExpression, alias *tsql.Identifier, defs []ast.Node) *ast.RangeFunction { call := &ast.FuncCall{ Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: name}}}, @@ -616,8 +621,10 @@ func (c *cc) rangeFunction(n tsql.Node, name string, args []tsql.ScalarExpressio call.Args.Items = append(call.Args.Items, c.convertScalarExpression(arg)) } rf := &ast.RangeFunction{ - Functions: &ast.List{Items: []ast.Node{&ast.List{Items: []ast.Node{call}}}}, - Coldeflist: &ast.List{Items: defs}, + Functions: &ast.List{Items: []ast.Node{&ast.List{Items: []ast.Node{call}}}}, + } + if len(defs) > 0 { + rf.Coldeflist = &ast.List{Items: defs} } if alias != nil { name := identifierValue(alias) @@ -1705,11 +1712,49 @@ func (c *cc) convertCreateSequenceStatement(n *tsql.CreateSequenceStatement) ast } } -// convertCreateFunctionStatement records a scalar function, whose result -// SQL Server reports nullable whatever its arguments are. +// convertCreateFunctionStatement records a function. A scalar function's +// result SQL Server reports nullable whatever its arguments are. A +// table-valued function returns rows of table(col type, ...), the columns +// it declares; an inline one's are those its query selects, which the +// schema works out from the query, passed as the "query" option. func (c *cc) convertCreateFunctionStatement(n *tsql.CreateFunctionStatement) ast.Node { - ret, ok := n.ReturnType.(*tsql.ScalarFunctionReturnType) - if !ok || ret.DataType == nil || n.Name == nil || n.Name.BaseIdentifier == nil { + if n.Name == nil || n.Name.BaseIdentifier == nil { + return todo(n) + } + var returns *ast.TypeName + var options *ast.List + switch ret := n.ReturnType.(type) { + case *tsql.ScalarFunctionReturnType: + if ret.DataType == nil { + return todo(n) + } + returns = nullableTypeName(dataTypeName(ret.DataType)) + case *tsql.TableValuedFunctionReturnType: + if ret.DeclareTableVariableBody == nil || ret.DeclareTableVariableBody.Definition == nil { + return todo(n) + } + var cols []string + for _, col := range ret.DeclareTableVariableBody.Definition.ColumnDefinitions { + def := c.convertColumnDefinition(col, nil) + t := def.TypeName + if !def.IsNotNull { + t = nullableTypeName(t) + } + spelled := core.TypeExprOfTypeName(t) + if spelled == nil { + return todo(n) + } + cols = append(cols, def.Colname+" "+typeSpelling(t, spelled)) + } + returns = &ast.TypeName{Spelling: "table(" + strings.Join(cols, ", ") + ")", Setof: true} + case *tsql.SelectFunctionReturnType: + if ret.SelectStatement == nil { + return todo(n) + } + returns = &ast.TypeName{Name: "table", Setof: true} + query := "query" + options = &ast.List{Items: []ast.Node{&ast.DefElem{Defname: &query, Arg: c.convertSelectStatement(ret.SelectStatement)}}} + default: return todo(n) } tn := parseTableName(n.Name) @@ -1728,8 +1773,18 @@ func (c *cc) convertCreateFunctionStatement(n *tsql.CreateFunctionStatement) ast return &ast.CreateFunctionStmt{ Func: &ast.FuncName{Schema: tn.Schema, Name: tn.Name}, Params: params, - ReturnType: nullableTypeName(dataTypeName(ret.DataType)), + ReturnType: returns, + Options: options, + } +} + +// typeSpelling spells a type so that it parses back as the same type, which +// for a nullable one is the Nullable(T) it was spelled as. +func typeSpelling(tn *ast.TypeName, t *core.TypeExpr) string { + if tn.Spelling != "" { + return tn.Spelling } + return t.String() } func sequenceFunc(name *tsql.SchemaObjectName) string { From f8a773fbafae6f690dd830ab3d49a738780acc14 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:19:52 -0800 Subject: [PATCH 52/74] mssql: select from a synonym the schema creates CREATE SYNONYM was ignored, so a query naming a synonym failed. A synonym is now recorded as a view of everything in what it names. A synonym may as well name a procedure, or something not yet created, which leaves nothing to select from it, so it is then left out. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/schema/schema.go | 17 ++++- .../testdata/analyze_synonyms/mssql/exec.json | 5 ++ .../testdata/analyze_synonyms/mssql/query.sql | 5 ++ .../analyze_synonyms/mssql/schema.sql | 8 +++ .../analyze_synonyms/mssql/stdout.json | 67 +++++++++++++++++++ internal/engine/mssql/convert.go | 20 ++++++ 6 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_synonyms/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_synonyms/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_synonyms/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_synonyms/mssql/stdout.json diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index 296f2644f3..d8a2fe6f54 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -48,7 +48,13 @@ func Apply(cat *core.Catalog, n ast.Node) error { case *ast.RenameTableStmt: return applyRenameTable(cat, v) case *ast.ViewStmt: - return applyView(cat, v.View, v.Aliases, v.Query, v.Replace) + err := applyView(cat, v.View, v.Aliases, v.Query, v.Replace) + // A synonym may name a procedure, or something created later, + // leaving nothing for a query to select from it. + if err != nil && hasOption(v.Options, "synonym") { + return nil + } + return err case *ast.CreateTableAsStmt: if v.Into == nil { return nil @@ -484,6 +490,15 @@ func applyCreateDomain(cat *core.Catalog, stmt *ast.CreateDomainStmt) error { return err } +func hasOption(options *ast.List, name string) bool { + for _, item := range listItems(options) { + if def, ok := item.(*ast.DefElem); ok && def.Defname != nil && *def.Defname == name { + return true + } + } + return false +} + // functionQuery is the query a function returns the rows of, which a // converter passes as the "query" option when the function's columns are // whatever it selects, as a SQL Server inline table-valued function's are. diff --git a/internal/endtoend/testdata/analyze_synonyms/mssql/exec.json b/internal/endtoend/testdata/analyze_synonyms/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_synonyms/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_synonyms/mssql/query.sql b/internal/endtoend/testdata/analyze_synonyms/mssql/query.sql new file mode 100644 index 0000000000..667ca9fda1 --- /dev/null +++ b/internal/endtoend/testdata/analyze_synonyms/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: WriterPeople :many +SELECT w.id, w.name FROM writers w JOIN app.people p ON p.id = w.id WHERE w.id = @id; + +-- name: AllWriters :many +SELECT * FROM writers; diff --git a/internal/endtoend/testdata/analyze_synonyms/mssql/schema.sql b/internal/endtoend/testdata/analyze_synonyms/mssql/schema.sql new file mode 100644 index 0000000000..0367b83159 --- /dev/null +++ b/internal/endtoend/testdata/analyze_synonyms/mssql/schema.sql @@ -0,0 +1,8 @@ +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(50) NULL); +GO +CREATE SCHEMA app; +GO +CREATE SYNONYM writers FOR dbo.authors; +CREATE SYNONYM app.people FOR authors; +CREATE SYNONYM later FOR dbo.not_yet_created; +CREATE SYNONYM remote FOR otherdb.dbo.authors; diff --git a/internal/endtoend/testdata/analyze_synonyms/mssql/stdout.json b/internal/endtoend/testdata/analyze_synonyms/mssql/stdout.json new file mode 100644 index 0000000000..400e73537f --- /dev/null +++ b/internal/endtoend/testdata/analyze_synonyms/mssql/stdout.json @@ -0,0 +1,67 @@ +[ + { + "name": "WriterPeople", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "writers" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "writers" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "writers" + } + } + ] + }, + { + "name": "AllWriters", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "writers" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "writers" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 0d491d419d..1d29040200 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -76,6 +76,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertCreateSequenceStatement(n) case *tsql.CreateFunctionStatement: return c.convertCreateFunctionStatement(n) + case *tsql.CreateSynonymStatement: + return c.convertCreateSynonymStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1778,6 +1780,24 @@ func (c *cc) convertCreateFunctionStatement(n *tsql.CreateFunctionStatement) ast } } +// convertCreateSynonymStatement records a synonym as a view of everything +// in what it names, marked a synonym since it may as well name something +// no query selects from, as a procedure. +func (c *cc) convertCreateSynonymStatement(n *tsql.CreateSynonymStatement) ast.Node { + if n.Name == nil || n.ForName == nil || n.ForName.BaseIdentifier == nil { + return todo(n) + } + synonym := "synonym" + return &ast.ViewStmt{ + View: c.parseRangeVar(n.Name), + Query: &ast.SelectStmt{ + TargetList: &ast.List{Items: []ast.Node{&ast.ResTarget{Val: &ast.ColumnRef{Fields: &ast.List{Items: []ast.Node{&ast.A_Star{}}}}}}}, + FromClause: &ast.List{Items: []ast.Node{c.parseRangeVar(n.ForName)}}, + }, + Options: &ast.List{Items: []ast.Node{&ast.DefElem{Defname: &synonym}}}, + } +} + // typeSpelling spells a type so that it parses back as the same type, which // for a nullable one is the Nullable(T) it was spelled as. func typeSpelling(tn *ast.TypeName, t *core.TypeExpr) string { From 886e8f504e67ec45f6d849f4db097634a6c507a2 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:23:31 -0800 Subject: [PATCH 53/74] mssql: type the methods of xml, geography, geometry and hierarchyid A method called on a value, as doc.exist('/a') or node.GetLevel() is, was taken for a function of that name, so its result went untyped. A method is now seeded as ".name" taking the value first, and a static one, as geography::Point(...), as "geography::point"; xml's value(path, 'type') returns the type it names. Each may return NULL. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_type_methods/mssql/exec.json | 5 + .../analyze_type_methods/mssql/query.sql | 10 + .../analyze_type_methods/mssql/schema.sql | 1 + .../analyze_type_methods/mssql/stdout.json | 196 ++++++++++++++++++ internal/engine/mssql/convert.go | 65 ++++++ internal/engine/mssql/dialect/functions.jsonl | 50 +++++ 6 files changed, 327 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_type_methods/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_type_methods/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json b/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql b/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql new file mode 100644 index 0000000000..0dd53b3f26 --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: Methods :one +SELECT doc.value('(/a/@n)[1]', 'int') AS v, doc.value('(/a)[1]', 'nvarchar(20)') AS s, + doc.exist('/a') AS e, geo.STDistance(geo) AS dist, + geo.STAsText() AS txt, shape.ToString() AS shape_text, node.ToString() AS path, + node.GetLevel() AS lvl, node.GetAncestor(@up) AS anc, + hierarchyid::GetRoot() AS root, geography::Point(@lat, @long, 4326) AS pt +FROM m WHERE id = @id; + +-- name: Nearby :many +SELECT id FROM m WHERE geo.STDistance(geography::Point(@lat, @long, 4326)) < @meters AND node.IsDescendantOf(@ancestor) = 1; diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql b/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql new file mode 100644 index 0000000000..88b8cb4b7e --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE m (id INT NOT NULL, doc XML NOT NULL, geo GEOGRAPHY NOT NULL, shape GEOMETRY NULL, node HIERARCHYID NOT NULL); diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json b/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json new file mode 100644 index 0000000000..c587ba6fbb --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json @@ -0,0 +1,196 @@ +[ + { + "name": "Methods", + "cmd": ":one", + "columns": [ + { + "name": "v", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "s", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "e", + "type": { + "name": "bit", + "nullable": true + } + }, + { + "name": "dist", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "txt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "shape_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "path", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "lvl", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "anc", + "type": { + "name": "hierarchyid", + "nullable": true + } + }, + { + "name": "root", + "type": { + "name": "hierarchyid", + "nullable": true + } + }, + { + "name": "pt", + "type": { + "name": "geography", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "up", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "lat", + "type": { + "name": "float" + } + } + }, + { + "number": 3, + "column": { + "name": "long", + "type": { + "name": "float" + } + } + }, + { + "number": 4, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "m" + } + } + ] + }, + { + "name": "Nearby", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "m" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "lat", + "type": { + "name": "float" + } + } + }, + { + "number": 2, + "column": { + "name": "long", + "type": { + "name": "float" + } + } + }, + { + "number": 3, + "column": { + "name": "meters", + "type": { + "name": "float", + "nullable": true + } + } + }, + { + "number": 4, + "column": { + "name": "ancestor", + "type": { + "name": "hierarchyid" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 1d29040200..eb6af1af7f 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -889,6 +889,9 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.ParenthesisExpression: return c.convertScalarExpression(e.Expression) case *tsql.FunctionCall: + if out := c.convertMethodCall(e); out != nil { + return out + } if e.OverClause == nil { if out := c.convertAlternatives(e); out != nil { return out @@ -1185,6 +1188,68 @@ type namedParam struct { name string } +// typeMethods are the methods of xml, geography, geometry and hierarchyid +// a query calls on a value, as doc.exist('/a') or node.GetLevel() do. A +// call to one is seeded as ".name" taking the value first, which tells it +// from a function in a schema, as dbo.f(), the parser sees alike. +var typeMethods = map[string]bool{ + "exist": true, + "getlevel": true, "tostring": true, "getancestor": true, "getdescendant": true, + "isdescendantof": true, "getreparentedvalue": true, + "stastext": true, "stasbinary": true, "starea": true, "stlength": true, + "stdistance": true, "stintersects": true, "stcontains": true, "stwithin": true, + "stequals": true, "stbuffer": true, "stunion": true, "stintersection": true, + "stnumpoints": true, "stgeometrytype": true, "stdimension": true, + "stisvalid": true, "stpointn": true, +} + +// convertMethodCall converts a call of a method on a value, or of a static +// one on a type, as geography::Point(...) is, seeded as "geography::point". +// xml's value(path, 'type') returns the type it names, or NULL when the +// path finds nothing. +func (c *cc) convertMethodCall(n *tsql.FunctionCall) ast.Node { + method := identifierValue(n.FunctionName) + var receiver ast.Node + switch t := n.CallTarget.(type) { + case *tsql.UserDefinedTypeCallTarget: + if t.SchemaObjectName == nil || t.SchemaObjectName.BaseIdentifier == nil { + return nil + } + fc := c.convertFunctionCall(n) + fc.Funcname = &ast.List{Items: []ast.Node{&ast.String{Str: identifierValue(t.SchemaObjectName.BaseIdentifier) + "::" + method}}} + return fc + case *tsql.MultiPartIdentifierCallTarget: + if t.MultiPartIdentifier == nil { + return nil + } + receiver = c.convertColumnReference(&tsql.ColumnReferenceExpression{MultiPartIdentifier: t.MultiPartIdentifier}) + case *tsql.ExpressionCallTarget: + receiver = c.convertScalarExpression(t.Expression) + default: + return nil + } + if method == "value" && len(n.Parameters) == 2 { + if lit, ok := n.Parameters[1].(*tsql.StringLiteral); ok { + return &ast.TypeCast{ + Arg: receiver, + TypeName: &ast.TypeName{Spelling: "Nullable(" + strings.ToLower(lit.Value) + ")"}, + Location: c.loc(n), + } + } + } + if !typeMethods[method] { + return nil + } + fc := c.convertFunctionCall(n) + fc.Funcname = &ast.List{Items: []ast.Node{&ast.String{Str: "." + method}}} + args := []ast.Node{receiver} + if fc.Args != nil { + args = append(args, fc.Args.Items...) + } + fc.Args = &ast.List{Items: args} + return fc +} + func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { fc := &ast.FuncCall{ Funcname: &ast.List{ diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 33b4af4c59..c55c8ce874 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -295,3 +295,53 @@ {"name": "contains", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} {"name": "freetext", "args": [{"type": "nvarchar(4000)"}], "returns": "bit"} {"name": "freetext", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} +{"name": ".exist", "args": [{"type": "xml"}, {"type": "nvarchar(4000)"}], "returns": "bit", "nullable": true} +{"name": ".getlevel", "args": [{"type": "hierarchyid"}], "returns": "smallint", "nullable": true} +{"name": ".tostring", "args": [{"type": "hierarchyid"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".getancestor", "args": [{"type": "hierarchyid"}, {"type": "int"}], "returns": "hierarchyid", "nullable": true} +{"name": ".getdescendant", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "hierarchyid", "nullable": true} +{"name": ".isdescendantof", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "bit", "nullable": true} +{"name": ".getreparentedvalue", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "hierarchyid", "nullable": true} +{"name": "hierarchyid::getroot", "args": [], "returns": "hierarchyid", "nullable": true} +{"name": "hierarchyid::parse", "args": [{"type": "nvarchar(4000)"}], "returns": "hierarchyid", "nullable": true} +{"name": ".tostring", "args": [{"type": "geography"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stastext", "args": [{"type": "geography"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stasbinary", "args": [{"type": "geography"}], "returns": "varbinary(max)", "nullable": true} +{"name": ".starea", "args": [{"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stlength", "args": [{"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stdistance", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stintersects", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stcontains", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stwithin", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stequals", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stisvalid", "args": [{"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stbuffer", "args": [{"type": "geography"}, {"type": "float"}], "returns": "geography", "nullable": true} +{"name": ".stunion", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "geography", "nullable": true} +{"name": ".stintersection", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "geography", "nullable": true} +{"name": ".stnumpoints", "args": [{"type": "geography"}], "returns": "int", "nullable": true} +{"name": ".stdimension", "args": [{"type": "geography"}], "returns": "int", "nullable": true} +{"name": ".stgeometrytype", "args": [{"type": "geography"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".stpointn", "args": [{"type": "geography"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "geography::stgeomfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "geography::stpointfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": ".tostring", "args": [{"type": "geometry"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stastext", "args": [{"type": "geometry"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stasbinary", "args": [{"type": "geometry"}], "returns": "varbinary(max)", "nullable": true} +{"name": ".starea", "args": [{"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stlength", "args": [{"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stdistance", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stintersects", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stcontains", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stwithin", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stequals", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stisvalid", "args": [{"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stbuffer", "args": [{"type": "geometry"}, {"type": "float"}], "returns": "geometry", "nullable": true} +{"name": ".stunion", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "geometry", "nullable": true} +{"name": ".stintersection", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "geometry", "nullable": true} +{"name": ".stnumpoints", "args": [{"type": "geometry"}], "returns": "int", "nullable": true} +{"name": ".stdimension", "args": [{"type": "geometry"}], "returns": "int", "nullable": true} +{"name": ".stgeometrytype", "args": [{"type": "geometry"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".stpointn", "args": [{"type": "geometry"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geometry::stgeomfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geometry::stpointfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geography::point", "args": [{"type": "float"}, {"type": "float"}, {"type": "int"}], "returns": "geography", "nullable": true} From 7e1952950936a0ea72d7093f87739de1abb39820 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:25:19 -0800 Subject: [PATCH 54/74] core: type a placeholder INSERT ... SELECT inserts as its column A placeholder in VALUES took the type of the column it is inserted into, but one selected by INSERT ... SELECT @a went untyped. A placeholder selected as it is now takes its column's type too. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/dml.go | 13 +++ .../mssql/exec.json | 5 + .../mssql/query.sql | 5 + .../mssql/schema.sql | 1 + .../mssql/stdout.json | 97 +++++++++++++++++++ 5 files changed, 121 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json diff --git a/internal/core/analyzer/dml.go b/internal/core/analyzer/dml.go index dc16d47ceb..9a158f474b 100644 --- a/internal/core/analyzer/dml.go +++ b/internal/core/analyzer/dml.go @@ -145,6 +145,19 @@ func (a *analyzer) bindInsertValues(n ast.Node, rel scopeRel, targets []core.Cla // INSERT ... SELECT inserts whatever the query returns. The rows are not // the statement's result, but the query still holds placeholders. if sel.ValuesLists == nil { + // A placeholder selected as it is takes the type of the column it + // is inserted into, as one in VALUES does. + if sel.Op == ast.None { + for i, item := range listItems(sel.TargetList) { + rt, ok := item.(*ast.ResTarget) + if !ok || i >= len(targets) { + continue + } + if p, ok := rt.Val.(*ast.ParamRef); ok { + a.inferParam(p, columnType(rel, targets[i])) + } + } + } _, err := a.subqueryColumns(sel) return err } diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json b/internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql new file mode 100644 index 0000000000..679a148aab --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: InsertSelected :exec +INSERT INTO t (id, name, at, n) SELECT @a, @b, @c, @d; + +-- name: CopyRow :exec +INSERT INTO t (id, name, at, n) SELECT @a, name, at, n + @inc FROM t WHERE id = @src; diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql b/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql new file mode 100644 index 0000000000..53c28cb58a --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2(3) NOT NULL, n BIGINT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json new file mode 100644 index 0000000000..1886cd3009 --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json @@ -0,0 +1,97 @@ +[ + { + "name": "InsertSelected", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "a", + "type": { + "name": "int" + }, + "table": "t" + } + }, + { + "number": 2, + "column": { + "name": "b", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "t" + } + }, + { + "number": 3, + "column": { + "name": "c", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + }, + "table": "t" + } + }, + { + "number": 4, + "column": { + "name": "d", + "type": { + "name": "bigint" + }, + "table": "t" + } + } + ] + }, + { + "name": "CopyRow", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "a", + "type": { + "name": "int" + }, + "table": "t" + } + }, + { + "number": 2, + "column": { + "name": "inc", + "type": { + "name": "bigint" + }, + "table": "t" + } + }, + { + "number": 3, + "column": { + "name": "src", + "type": { + "name": "int" + }, + "table": "t" + } + } + ] + } +] From 170e54a5b945e987715cd3e8e999289b91767c52 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:27:01 -0800 Subject: [PATCH 55/74] core: type a placeholder among alternatives as the others combine A placeholder passed to COALESCE, GREATEST, LEAST or IIF, or returned by a CASE branch, went untyped. It now takes the type the other alternatives combine to; one in COALESCE may be NULL, since that is what passing it there is for. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/expr.go | 16 +++ .../mssql/exec.json | 5 + .../mssql/query.sql | 4 + .../mssql/schema.sql | 1 + .../mssql/stdout.json | 122 ++++++++++++++++++ 5 files changed, 148 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json diff --git a/internal/core/analyzer/expr.go b/internal/core/analyzer/expr.go index 8925f69be4..7ebebe9b25 100644 --- a/internal/core/analyzer/expr.go +++ b/internal/core/analyzer/expr.go @@ -514,6 +514,8 @@ func (a *analyzer) typeCoalesce(e *ast.CoalesceExpr) (exprType, error) { } } } + // A placeholder there is one that may be NULL. + a.inferAlternatives(listItems(e.Args), t, true) // The result is an expression's, not the column's it came from. return exprType{typeOID: t.typeOID, expr: t.expr, nullable: nullable}, nil } @@ -533,10 +535,24 @@ func (a *analyzer) typeFirstOf(nodes []ast.Node, nullable bool) (exprType, error nullable = nullable || t.nullable } out := a.commonType(types) + a.inferAlternatives(nodes, out, false) out.nullable = nullable return out, nil } +// inferAlternatives types a placeholder among alternatives as the type the +// others combine to, as GREATEST(1, @n) takes @n as an integer. +func (a *analyzer) inferAlternatives(nodes []ast.Node, t exprType, nullable bool) { + if t.typeOID == 0 && t.expr == nil { + return + } + for _, n := range nodes { + if p, ok := n.(*ast.ParamRef); ok { + a.inferParam(p, exprType{typeOID: t.typeOID, expr: t.expr, nullable: nullable}) + } + } +} + // typeArrayExpr types ARRAY[...], whose type is an array of its elements'. func (a *analyzer) typeArrayExpr(e *ast.A_ArrayExpr) (exprType, error) { elemT, err := a.typeFirstOf(listItems(e.Elements), false) diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json b/internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql b/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql new file mode 100644 index 0000000000..21aae2f85a --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql @@ -0,0 +1,4 @@ +-- name: Alternatives :many +SELECT GREATEST(1, @n) AS g, LEAST(n, @cap) AS l, COALESCE(@x, name) AS c, + CASE WHEN id > 0 THEN @label ELSE name END AS k, IIF(id > 0, @alt, at) AS i +FROM t; diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql b/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql new file mode 100644 index 0000000000..53c28cb58a --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2(3) NOT NULL, n BIGINT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json b/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json new file mode 100644 index 0000000000..23fa44d170 --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json @@ -0,0 +1,122 @@ +[ + { + "name": "Alternatives", + "cmd": ":many", + "columns": [ + { + "name": "g", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "l", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "t" + }, + { + "name": "c", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "k", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "i", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "cap", + "type": { + "name": "bigint" + } + } + }, + { + "number": 3, + "column": { + "name": "x", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + } + }, + { + "number": 4, + "column": { + "name": "label", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 50 + } + ] + } + } + }, + { + "number": 5, + "column": { + "name": "alt", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + } + } + } + ] + } +] From 33db6e477e819252b20eb998f3d83bcc8fa2b5ab Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:29:09 -0800 Subject: [PATCH 56/74] mssql: gofmt typeMethods Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/engine/mssql/convert.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index eb6af1af7f..21472d1c97 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1193,7 +1193,7 @@ type namedParam struct { // call to one is seeded as ".name" taking the value first, which tells it // from a function in a schema, as dbo.f(), the parser sees alike. var typeMethods = map[string]bool{ - "exist": true, + "exist": true, "getlevel": true, "tostring": true, "getancestor": true, "getdescendant": true, "isdescendantof": true, "getreparentedvalue": true, "stastext": true, "stasbinary": true, "starea": true, "stlength": true, From a7951eddfb9e4c6e61432469037edb5bf1b894e2 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:30:57 -0800 Subject: [PATCH 57/74] mssql: seed more built-in functions GROUPING, GROUPING_ID, APPROX_COUNT_DISTINCT, CHECKSUM_AGG and PERCENTILE_CONT; the metadata functions, as DB_NAME, OBJECT_ID and IDENT_CURRENT; the ERROR_* functions, XACT_STATE and SESSION_CONTEXT; STRING_ESCAPE, SOUNDEX, DIFFERENCE, FORMATMESSAGE, COMPRESS and DECOMPRESS; the bit functions; DATE_BUCKET; the REGEXP_* functions; VECTOR_DISTANCE; and LTRIM and RTRIM given the characters to trim. Each was untyped. Their types are those SQL Server reports. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_more_functions/mssql/exec.json | 5 + .../analyze_more_functions/mssql/query.sql | 22 ++ .../analyze_more_functions/mssql/schema.sql | 1 + .../analyze_more_functions/mssql/stdout.json | 367 ++++++++++++++++++ internal/engine/mssql/dialect/functions.jsonl | 73 ++++ 5 files changed, 468 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_more_functions/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_more_functions/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql new file mode 100644 index 0000000000..f9db529a01 --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql @@ -0,0 +1,22 @@ +-- name: Grouping :many +SELECT g, GROUPING(g) AS gr, GROUPING_ID(g, id) AS gid, APPROX_COUNT_DISTINCT(id) AS approx, CHECKSUM_AGG(id) AS ca +FROM s GROUP BY ROLLUP(g, id); + +-- name: Percentiles :many +SELECT PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY v) OVER (PARTITION BY g) AS med FROM s; + +-- name: Metadata :one +SELECT DB_NAME() AS d, SCHEMA_NAME() AS sn, OBJECT_ID(N'dbo.s') AS o, OBJECT_NAME(@oid) AS obj, + IDENT_CURRENT(N's') AS ic, ROWCOUNT_BIG() AS rc, ORIGINAL_LOGIN() AS ol, DB_ID() AS dbid, + ERROR_MESSAGE() AS em, ERROR_NUMBER() AS en, XACT_STATE() AS xs, SESSION_CONTEXT(N'k') AS sc; + +-- name: Strings :many +SELECT STRING_ESCAPE(g, 'json') AS se, SOUNDEX(g) AS sx, DIFFERENCE(g, @other) AS df, + LTRIM(g, N'x') AS lt, RTRIM(g, N'x') AS rt, COMPRESS(g) AS c, REGEXP_REPLACE(g, @pattern, N'b') AS rr, + REGEXP_SUBSTR(g, N'a') AS rs, REGEXP_COUNT(g, N'a') AS rc +FROM s; + +-- name: Bits :many +SELECT BIT_COUNT(id) AS bc, LEFT_SHIFT(id, 1) AS ls, GET_BIT(id, 1) AS gb, SET_BIT(id, @bit) AS sb, + DATE_BUCKET(week, 2, CAST(SYSDATETIME() AS date)) AS db +FROM s; diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql new file mode 100644 index 0000000000..dc9cce113a --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE s (id INT NOT NULL, g NVARCHAR(10) NOT NULL, v DECIMAL(10,2) NOT NULL, f FLOAT NULL); diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json new file mode 100644 index 0000000000..ff93fb5e24 --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json @@ -0,0 +1,367 @@ +[ + { + "name": "Grouping", + "cmd": ":many", + "columns": [ + { + "name": "g", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + }, + "table": "s" + }, + { + "name": "gr", + "type": { + "name": "tinyint" + } + }, + { + "name": "gid", + "type": { + "name": "int" + } + }, + { + "name": "approx", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "ca", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Percentiles", + "cmd": ":many", + "columns": [ + { + "name": "med", + "type": { + "name": "float", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Metadata", + "cmd": ":one", + "columns": [ + { + "name": "d", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "sn", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "o", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "obj", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "ic", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 38 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "rc", + "type": { + "name": "bigint" + } + }, + { + "name": "ol", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "dbid", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "em", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "en", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "xs", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "sc", + "type": { + "name": "sql_variant", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "oid", + "type": { + "name": "int" + } + } + } + ] + }, + { + "name": "Strings", + "cmd": ":many", + "columns": [ + { + "name": "se", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "sx", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "df", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "lt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "rt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "c", + "type": { + "name": "varbinary", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "rr", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "rs", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "rc", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "other", + "type": { + "name": "varchar" + } + } + }, + { + "number": 2, + "column": { + "name": "pattern" + } + } + ] + }, + { + "name": "Bits", + "cmd": ":many", + "columns": [ + { + "name": "bc", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "ls", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "gb", + "type": { + "name": "bit", + "nullable": true + } + }, + { + "name": "sb", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "db", + "type": { + "name": "date", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "bit", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index c55c8ce874..d9f7c75245 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -345,3 +345,76 @@ {"name": "geometry::stgeomfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} {"name": "geometry::stpointfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} {"name": "geography::point", "args": [{"type": "float"}, {"type": "float"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "grouping", "kind": "a", "args": [{"type": "any"}], "returns": "tinyint", "never_null": true} +{"name": "grouping_id", "kind": "a", "args": [{"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "never_null": true} +{"name": "approx_count_distinct", "kind": "a", "args": [{"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "checksum_agg", "kind": "a", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "percentile_cont", "kind": "w", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "ident_current", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "ident_seed", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "ident_incr", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "rowcount_big", "returns": "bigint", "never_null": true} +{"name": "db_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_sname", "returns": "nvarchar(128)", "nullable": true} +{"name": "schema_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "user_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "db_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_sname", "args": [{"type": "varbinary"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "schema_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "user_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "host_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "app_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "current_timezone", "returns": "nvarchar(128)", "nullable": true} +{"name": "current_timezone_id", "returns": "nvarchar(128)", "nullable": true} +{"name": "error_procedure", "returns": "nvarchar(128)", "nullable": true} +{"name": "original_login", "returns": "nvarchar(4000)", "nullable": true} +{"name": "object_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "object_id", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "object_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_schema_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_schema_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_definition", "args": [{"type": "int"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "db_id", "returns": "smallint", "nullable": true} +{"name": "db_id", "args": [{"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "user_id", "returns": "smallint", "nullable": true} +{"name": "user_id", "args": [{"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "suser_id", "returns": "int", "nullable": true} +{"name": "suser_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "schema_id", "returns": "int", "nullable": true} +{"name": "schema_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "suser_sid", "returns": "varbinary(85)", "nullable": true} +{"name": "col_length", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "col_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "type_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "error_number", "returns": "int", "nullable": true} +{"name": "error_severity", "returns": "int", "nullable": true} +{"name": "error_state", "returns": "int", "nullable": true} +{"name": "error_line", "returns": "int", "nullable": true} +{"name": "error_message", "returns": "nvarchar(4000)", "nullable": true} +{"name": "xact_state", "returns": "smallint", "nullable": true} +{"name": "session_context", "args": [{"type": "nvarchar"}], "returns": "sql_variant", "nullable": true} +{"name": "context_info", "returns": "varbinary(128)", "nullable": true} +{"name": "sql_variant_property", "args": [{"type": "any"}, {"type": "varchar"}], "returns": "sql_variant", "nullable": true} +{"name": "string_escape", "args": [{"type": "nvarchar"}, {"type": "varchar"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "soundex", "args": [{"type": "varchar"}], "returns": "varchar(5)", "nullable": true} +{"name": "difference", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "formatmessage", "args": [{"type": "any"}, {"type": "any", "mode": "v"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "ltrim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "rtrim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "compress", "args": [{"type": "any"}], "returns": "varbinary(max)", "nullable": true} +{"name": "decompress", "args": [{"type": "any"}], "returns": "varbinary(max)", "nullable": true} +{"name": "bit_count", "args": [{"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "left_shift", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "right_shift", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "get_bit", "args": [{"type": "any"}, {"type": "int"}], "returns": "bit", "nullable": true} +{"name": "set_bit", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "set_bit", "args": [{"type": "any"}, {"type": "int"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "date_bucket", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "date_bucket", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "regexp_replace", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "regexp_substr", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "$1", "nullable": true} +{"name": "regexp_instr", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} +{"name": "regexp_count", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} +{"name": "vector_distance", "args": [{"type": "varchar"}, {"type": "vector"}, {"type": "vector"}], "returns": "float", "nullable": true} From 4358b1c5438cc3010a193024e40ff9019011e9aa Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:35:07 -0800 Subject: [PATCH 58/74] mssql: apply ALTER SCHEMA ... TRANSFER ALTER SCHEMA s TRANSFER t, which moves a table or view to schema s, was ignored, leaving t where it was. The core schema now moves a relation for ALTER TABLE ... SET SCHEMA, which PostgreSQL's converter already produces, and SQL Server's TRANSFER converts to it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/catalogdb/query.sql.go | 14 +++++ internal/core/catalogdef/query.sql | 3 + internal/core/class.go | 12 ++++ internal/core/schema/schema.go | 21 +++++++ .../analyze_schema_transfer/mssql/exec.json | 5 ++ .../analyze_schema_transfer/mssql/query.sql | 5 ++ .../analyze_schema_transfer/mssql/schema.sql | 10 ++++ .../analyze_schema_transfer/mssql/stdout.json | 56 +++++++++++++++++++ internal/engine/mssql/convert.go | 23 ++++++++ 9 files changed, 149 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_schema_transfer/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_schema_transfer/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_schema_transfer/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_schema_transfer/mssql/stdout.json diff --git a/internal/core/catalogdb/query.sql.go b/internal/core/catalogdb/query.sql.go index ba4ee026d2..1e274aef21 100644 --- a/internal/core/catalogdb/query.sql.go +++ b/internal/core/catalogdb/query.sql.go @@ -1143,6 +1143,20 @@ func (q *Queries) SetAttributeUnique(ctx context.Context, arg SetAttributeUnique return err } +const setClassNamespace = `-- name: SetClassNamespace :exec +UPDATE sql_class SET namespace_oid = ?1 WHERE oid = ?2 +` + +type SetClassNamespaceParams struct { + NamespaceOid int64 + Oid int64 +} + +func (q *Queries) SetClassNamespace(ctx context.Context, arg SetClassNamespaceParams) error { + _, err := q.db.ExecContext(ctx, setClassNamespace, arg.NamespaceOid, arg.Oid) + return err +} + const setDialectFlag = `-- name: SetDialectFlag :exec INSERT INTO sql_dialect_flag (dialect_oid, key, value) VALUES (?, ?, ?) diff --git a/internal/core/catalogdef/query.sql b/internal/core/catalogdef/query.sql index 2c56ac5d15..4c1ff65e11 100644 --- a/internal/core/catalogdef/query.sql +++ b/internal/core/catalogdef/query.sql @@ -149,6 +149,9 @@ DELETE FROM sql_class WHERE oid = ?; -- name: RenameClass :exec UPDATE sql_class SET name = sqlc.arg(new_name) WHERE oid = sqlc.arg(oid); +-- name: SetClassNamespace :exec +UPDATE sql_class SET namespace_oid = sqlc.arg(namespace_oid) WHERE oid = sqlc.arg(oid); + -- ============================= sql_attribute =========================== -- name: CreateAttribute :exec diff --git a/internal/core/class.go b/internal/core/class.go index 7f3e140939..3fdf7142fc 100644 --- a/internal/core/class.go +++ b/internal/core/class.go @@ -60,6 +60,18 @@ func (c *Catalog) RenameClass(classOID int64, name string) error { return nil } +// SetClassNamespace moves a relation to another namespace. +func (c *Catalog) SetClassNamespace(classOID, namespaceOID int64) error { + err := c.q.SetClassNamespace(context.Background(), catalogdb.SetClassNamespaceParams{ + Oid: classOID, + NamespaceOid: namespaceOID, + }) + if err != nil { + return fmt.Errorf("set namespace of class %d: %w", classOID, err) + } + return nil +} + type ClassInfo struct { OID int64 Name string diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index d8a2fe6f54..27b7242a3d 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -47,6 +47,8 @@ func Apply(cat *core.Catalog, n ast.Node) error { return applyRenameColumn(cat, v) case *ast.RenameTableStmt: return applyRenameTable(cat, v) + case *ast.AlterTableSetSchemaStmt: + return applySetSchema(cat, v) case *ast.ViewStmt: err := applyView(cat, v.View, v.Aliases, v.Query, v.Replace) // A synonym may name a procedure, or something created later, @@ -405,6 +407,25 @@ func applyRenameTable(cat *core.Catalog, stmt *ast.RenameTableStmt) error { return cat.RenameClass(classOID, *stmt.NewName) } +// applySetSchema moves a relation to another schema. +func applySetSchema(cat *core.Catalog, stmt *ast.AlterTableSetSchemaStmt) error { + if stmt.NewSchema == nil { + return nil + } + classOID, err := lookupClass(cat, stmt.Table) + if err != nil { + if stmt.MissingOk { + return nil + } + return err + } + nsOID, err := resolveOrCreateNamespace(cat, *stmt.NewSchema) + if err != nil { + return err + } + return cat.SetClassNamespace(classOID, nsOID) +} + func lookupClass(cat *core.Catalog, table *ast.TableName) (int64, error) { if table == nil { return 0, fmt.Errorf("missing table name") diff --git a/internal/endtoend/testdata/analyze_schema_transfer/mssql/exec.json b/internal/endtoend/testdata/analyze_schema_transfer/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_schema_transfer/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_schema_transfer/mssql/query.sql b/internal/endtoend/testdata/analyze_schema_transfer/mssql/query.sql new file mode 100644 index 0000000000..dd0aa9cb60 --- /dev/null +++ b/internal/endtoend/testdata/analyze_schema_transfer/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: SalesOrders :many +SELECT id, total FROM sales.orders WHERE id = @id; + +-- name: StagingItems :many +SELECT id FROM staging_items; diff --git a/internal/endtoend/testdata/analyze_schema_transfer/mssql/schema.sql b/internal/endtoend/testdata/analyze_schema_transfer/mssql/schema.sql new file mode 100644 index 0000000000..c5d03327db --- /dev/null +++ b/internal/endtoend/testdata/analyze_schema_transfer/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE orders (id INT NOT NULL, total DECIMAL(10,2) NOT NULL); +CREATE TABLE staging_items (id INT NOT NULL); +GO +CREATE SCHEMA sales; +GO +CREATE SCHEMA archive; +GO +ALTER SCHEMA sales TRANSFER dbo.orders; +ALTER SCHEMA archive TRANSFER OBJECT::staging_items; +ALTER SCHEMA dbo TRANSFER archive.staging_items; diff --git a/internal/endtoend/testdata/analyze_schema_transfer/mssql/stdout.json b/internal/endtoend/testdata/analyze_schema_transfer/mssql/stdout.json new file mode 100644 index 0000000000..8e4cbd11c0 --- /dev/null +++ b/internal/endtoend/testdata/analyze_schema_transfer/mssql/stdout.json @@ -0,0 +1,56 @@ +[ + { + "name": "SalesOrders", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "orders" + }, + { + "name": "total", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "orders" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "orders" + } + } + ] + }, + { + "name": "StagingItems", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "staging_items" + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 21472d1c97..057ab71c60 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -78,6 +78,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertCreateFunctionStatement(n) case *tsql.CreateSynonymStatement: return c.convertCreateSynonymStatement(n) + case *tsql.AlterSchemaStatement: + return c.convertAlterSchemaStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1863,6 +1865,27 @@ func (c *cc) convertCreateSynonymStatement(n *tsql.CreateSynonymStatement) ast.N } } +// convertAlterSchemaStatement converts ALTER SCHEMA s TRANSFER t, which +// moves a table or view to schema s. Transferring a type is not followed. +func (c *cc) convertAlterSchemaStatement(n *tsql.AlterSchemaStatement) ast.Node { + if n.Name == nil || n.ObjectName == nil || n.ObjectName.BaseIdentifier == nil { + return todo(n) + } + switch strings.ToLower(n.ObjectKind) { + case "", "notspecified", "object": + default: + return todo(n) + } + schema := identifier(n.Name.Value) + if schema == "dbo" { + schema = "" + } + return &ast.AlterTableSetSchemaStmt{ + Table: parseTableName(n.ObjectName), + NewSchema: &schema, + } +} + // typeSpelling spells a type so that it parses back as the same type, which // for a nullable one is the Nullable(T) it was spelled as. func typeSpelling(tn *ast.TypeName, t *core.TypeExpr) string { From 67d9190df150ef69f92ce0ed5987d83a1b8dff16 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:38:38 -0800 Subject: [PATCH 59/74] mssql: type LEFT, RIGHT and TRIM(chars FROM string) LEFT and RIGHT, which the parser gives nodes of their own, were not converted, so their results went untyped, and TRIM(chars FROM string) took the type of the characters. LEFT and RIGHT are now called, taking their length as the int SQL Server does, and TRIM given the characters returns the string's type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_left_right_trim/mssql/exec.json | 5 ++ .../analyze_left_right_trim/mssql/query.sql | 2 + .../analyze_left_right_trim/mssql/schema.sql | 1 + .../analyze_left_right_trim/mssql/stdout.json | 55 +++++++++++++++++++ internal/engine/mssql/convert.go | 18 ++++++ internal/engine/mssql/dialect/functions.jsonl | 17 +++--- 6 files changed, 90 insertions(+), 8 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json b/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql new file mode 100644 index 0000000000..6ce39b24e8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Trimmed :many +SELECT LEFT(a, 3) AS lf, RIGHT(c, @n) AS rt, TRIM(N'x' FROM a) AS tr, TRIM(LEADING 'x' FROM c) AS tl FROM p; diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql b/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json new file mode 100644 index 0000000000..57527e3607 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json @@ -0,0 +1,55 @@ +[ + { + "name": "Trimmed", + "cmd": ":many", + "columns": [ + { + "name": "lf", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "rt", + "type": { + "name": "varchar", + "nullable": true + } + }, + { + "name": "tr", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "tl", + "type": { + "name": "varchar", + "args": [ + { + "int": 5 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 057ab71c60..bffeb2990e 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1007,6 +1007,10 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { }, Location: c.loc(e), } + case *tsql.LeftFunctionCall: + return c.namedCall("left", e.Parameters, e) + case *tsql.RightFunctionCall: + return c.namedCall("right", e.Parameters, e) case *tsql.NextValueForExpression: if e.SequenceName == nil { return todo(e) @@ -1886,6 +1890,20 @@ func (c *cc) convertAlterSchemaStatement(n *tsql.AlterSchemaStatement) ast.Node } } +// namedCall is a call of name with args, for a function the parser gives a +// node of its own, as LEFT and RIGHT, which are keywords too. +func (c *cc) namedCall(name string, args []tsql.ScalarExpression, n tsql.Node) *ast.FuncCall { + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: name}}}, + Args: &ast.List{}, + Location: c.loc(n), + } + for _, arg := range args { + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(arg)) + } + return call +} + // typeSpelling spells a type so that it parses back as the same type, which // for a nullable one is the Nullable(T) it was spelled as. func typeSpelling(tn *ast.TypeName, t *core.TypeExpr) string { diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index d9f7c75245..021afb47b6 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -110,14 +110,14 @@ {"name": "substring", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} {"name": "substring", "args": [{"type": "varbinary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} {"name": "substring", "args": [{"type": "binary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} -{"name": "left", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "left", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "left", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} -{"name": "left", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} -{"name": "right", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "right", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "right", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} -{"name": "right", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "left", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "left", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} {"name": "replace", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} {"name": "replace", "args": [{"type": "char"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} {"name": "replace", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} @@ -418,3 +418,4 @@ {"name": "regexp_instr", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} {"name": "regexp_count", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} {"name": "vector_distance", "args": [{"type": "varchar"}, {"type": "vector"}, {"type": "vector"}], "returns": "float", "nullable": true} +{"name": "trim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$2"} From baf1ec3955c0c4866a42c3e71347ebce18c145d0 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:39:32 -0800 Subject: [PATCH 60/74] mssql: take REPLICATE's and CHARINDEX's integer arguments as int A placeholder for the count REPLICATE repeats a string, or the position CHARINDEX starts at, was a bigint, where SQL Server takes an int. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_left_right_trim/mssql/query.sql | 3 ++ .../analyze_left_right_trim/mssql/stdout.json | 40 +++++++++++++++++++ internal/engine/mssql/dialect/functions.jsonl | 10 ++--- 3 files changed, 48 insertions(+), 5 deletions(-) diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql index 6ce39b24e8..9eb8705b85 100644 --- a/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql @@ -1,2 +1,5 @@ -- name: Trimmed :many SELECT LEFT(a, 3) AS lf, RIGHT(c, @n) AS rt, TRIM(N'x' FROM a) AS tr, TRIM(LEADING 'x' FROM c) AS tl FROM p; + +-- name: Repeated :many +SELECT REPLICATE(a, @r) AS r, CHARINDEX(N'x', a, @ci) AS ci FROM p; diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json index 57527e3607..4743bd3f92 100644 --- a/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json @@ -51,5 +51,45 @@ } } ] + }, + { + "name": "Repeated", + "cmd": ":many", + "columns": [ + { + "name": "r", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "ci", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "r", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "ci", + "type": { + "name": "int" + } + } + } + ] } ] diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 021afb47b6..5e4011e89a 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -124,10 +124,10 @@ {"name": "replace", "args": [{"type": "nchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} {"name": "translate", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} {"name": "translate", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} -{"name": "replicate", "args": [{"type": "varchar"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "replicate", "args": [{"type": "char"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} -{"name": "replicate", "args": [{"type": "nvarchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} -{"name": "replicate", "args": [{"type": "nchar"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "replicate", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} {"name": "reverse", "args": [{"type": "varchar"}], "returns": "$1", "nullable": true} {"name": "reverse", "args": [{"type": "char"}], "returns": "varchar", "nullable": true} {"name": "reverse", "args": [{"type": "nvarchar"}], "returns": "$1", "nullable": true} @@ -138,7 +138,7 @@ {"name": "stuff", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "nvarchar", "nullable": true} {"name": "space", "args": [{"type": "int"}], "returns": "varchar(8000)", "nullable": true} {"name": "charindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} -{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}, {"type": "bigint"}], "returns": "int", "nullable": true} +{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}, {"type": "int"}], "returns": "int", "nullable": true} {"name": "patindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} {"name": "ascii", "args": [{"type": "varchar"}], "returns": "int", "nullable": true} {"name": "unicode", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} From 4e345d063aa5af09b52669cfd67ecf8442328829 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:41:34 -0800 Subject: [PATCH 61/74] mssql: type an N'...' literal as nvarchar A Unicode string literal was typed as a varchar, as any string literal is. N'...' is now an nvarchar as long as the string, as SQL Server types it. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_national_literals/mssql/exec.json | 5 ++ .../analyze_national_literals/mssql/query.sql | 2 + .../mssql/schema.sql | 1 + .../mssql/stdout.json | 70 +++++++++++++++++++ internal/engine/mssql/convert.go | 8 ++- 5 files changed, 85 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_national_literals/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_national_literals/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json b/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql b/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql new file mode 100644 index 0000000000..6c70713f9e --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Literals :many +SELECT N'hello' AS a1, N'' AS a2, 'hi' AS a3, a + N'xy' AS a4, COALESCE(NULLIF(a, N''), N'none') AS a5 FROM p WHERE a LIKE N'%x%' AND b = @b; diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql b/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json b/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json new file mode 100644 index 0000000000..2e689dcf2f --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json @@ -0,0 +1,70 @@ +[ + { + "name": "Literals", + "cmd": ":many", + "columns": [ + { + "name": "a1", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "a2", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 1 + } + ] + } + }, + { + "name": "a3", + "type": { + "name": "varchar" + } + }, + { + "name": "a4", + "type": { + "name": "nvarchar" + } + }, + { + "name": "a5", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "b", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 20 + } + ] + }, + "table": "p" + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index bffeb2990e..a25640fa72 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -3,6 +3,7 @@ package mssql import ( "strconv" "strings" + "unicode/utf16" tsql "github.com/sqlc-dev/teesql/ast" @@ -846,10 +847,15 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Location: c.loc(e), } case *tsql.StringLiteral: - return &ast.A_Const{ + lit := &ast.A_Const{ Val: &ast.String{Str: e.Value}, Location: c.loc(e), } + // N'...' is an nvarchar as long as the string, and at least 1. + if e.IsNational { + return &ast.TypeCast{Arg: lit, TypeName: typeName("nvarchar", max(1, int64(len(utf16.Encode([]rune(e.Value)))))), Location: c.loc(e)} + } + return lit case *tsql.NullLiteral: return &ast.A_Const{ Val: &ast.Null{}, From 3257c15f082cc6aa89881827e69bb82c1a49a3f1 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:45:59 -0800 Subject: [PATCH 62/74] core: find the family of a type given default arguments A type the catalog holds no row for, as decimal(5,1) cast to before any column has it, is looked up by its family. Looking the family up by its bare name applied the dialect's default arguments again, as SQL Server's decimal is decimal(18,0), which held no row either, so the expression went untyped and its operators resolved against nothing. The family is now found by name when its bare name is no row. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/types.go | 6 ++++- .../mssql/exec.json | 5 ++++ .../mssql/query.sql | 2 ++ .../mssql/schema.sql | 1 + .../mssql/stdout.json | 27 +++++++++++++++++++ 5 files changed, 40 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json diff --git a/internal/core/types.go b/internal/core/types.go index 7c482a1f2b..99c38e2cb3 100644 --- a/internal/core/types.go +++ b/internal/core/types.go @@ -659,7 +659,11 @@ func (c *Catalog) LookupTypeExpr(t *TypeExpr) (TypeLookup, bool) { // The family is known and the instance is not a row. familyOID, _, err := c.internType(&TypeExpr{Name: canonical.Name}, refuse, false) if err != nil { - return TypeLookup{}, false + // The bare name may take default arguments, as SQL Server's + // decimal is decimal(18,0), and so name no row either. + if familyOID, err = c.TypeOID(canonical.Name); err != nil { + return TypeLookup{}, false + } } return TypeLookup{OID: familyOID, FamilyOID: familyOID, Expr: canonical}, true } diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql new file mode 100644 index 0000000000..4b81abc310 --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Negated :many +SELECT -CAST(i AS DECIMAL) AS nd, i - CAST(f AS DECIMAL(5,1)) AS diff, d * CAST(i AS DECIMAL(12,3)) AS product FROM p2; diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql new file mode 100644 index 0000000000..e1944ab1c9 --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p2 (d DECIMAL(10,2) NOT NULL, i INT NOT NULL, f FLOAT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json new file mode 100644 index 0000000000..1256449c2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json @@ -0,0 +1,27 @@ +[ + { + "name": "Negated", + "cmd": ":many", + "columns": [ + { + "name": "nd", + "type": { + "name": "decimal" + } + }, + { + "name": "diff", + "type": { + "name": "decimal" + } + }, + { + "name": "product", + "type": { + "name": "decimal" + } + } + ], + "params": [] + } +] From b4cbd83140208a14baad38604cfafd5e593060a8 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:47:36 -0800 Subject: [PATCH 63/74] mssql: type a number with a decimal point as decimal A literal such as 1.5 was typed as a float, and one too large for an int, as 2147483648, as one too. SQL Server types each as the decimal holding its digits, 1.5 as decimal(2,1) and 2147483648 as decimal(10,0), and so now does sqlc. 1e5 is still a float. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_numeric_literals/mssql/exec.json | 5 + .../analyze_numeric_literals/mssql/query.sql | 2 + .../analyze_numeric_literals/mssql/schema.sql | 1 + .../mssql/stdout.json | 117 ++++++++++++++++++ internal/engine/mssql/convert.go | 27 +++- 5 files changed, 147 insertions(+), 5 deletions(-) create mode 100644 internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json b/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql b/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql new file mode 100644 index 0000000000..886b0e0ab1 --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Literals :many +SELECT 1.5 AS a, 0.5 AS b, 10.00 AS c, 007.10 AS d, 2147483647 AS e, 2147483648 AS f, 12345678901 AS g, -1.5 AS h, 1e5 AS i, 0 - 1.5 AS j FROM p; diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql b/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json b/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json new file mode 100644 index 0000000000..33e44239aa --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json @@ -0,0 +1,117 @@ +[ + { + "name": "Literals", + "cmd": ":many", + "columns": [ + { + "name": "a", + "type": { + "name": "decimal", + "args": [ + { + "int": 2 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "b", + "type": { + "name": "decimal", + "args": [ + { + "int": 1 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "c", + "type": { + "name": "decimal", + "args": [ + { + "int": 4 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "d", + "type": { + "name": "decimal", + "args": [ + { + "int": 3 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "e", + "type": { + "name": "int" + } + }, + { + "name": "f", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "g", + "type": { + "name": "decimal", + "args": [ + { + "int": 11 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "h", + "type": { + "name": "decimal" + } + }, + { + "name": "i", + "type": { + "name": "float" + } + }, + { + "name": "j", + "type": { + "name": "decimal" + } + } + ], + "params": [] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index a25640fa72..f1da1c4a8b 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1,6 +1,7 @@ package mssql import ( + "math" "strconv" "strings" "unicode/utf16" @@ -826,16 +827,16 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.VariableReference: return c.convertVariableReference(e) case *tsql.IntegerLiteral: - ival, _ := strconv.ParseInt(e.Value, 10, 64) + ival, err := strconv.ParseInt(e.Value, 10, 64) + if err != nil || ival > math.MaxInt32 { + return c.numericLiteral(e.Value, e) + } return &ast.A_Const{ Val: &ast.Integer{Ival: ival}, Location: c.loc(e), } case *tsql.NumericLiteral: - return &ast.A_Const{ - Val: &ast.Float{Str: e.Value}, - Location: c.loc(e), - } + return c.numericLiteral(e.Value, e) case *tsql.RealLiteral: return &ast.A_Const{ Val: &ast.Float{Str: e.Value}, @@ -1896,6 +1897,22 @@ func (c *cc) convertAlterSchemaStatement(n *tsql.AlterSchemaStatement) ast.Node } } +// numericLiteral is a number written with a decimal point, or too large +// for an int, which SQL Server types as the decimal holding its digits: +// 1.50 is a decimal(3,2), 2147483648 a decimal(10,0). +func (c *cc) numericLiteral(value string, n tsql.Node) ast.Node { + whole, frac, _ := strings.Cut(value, ".") + whole = strings.TrimLeft(whole, "0") + scale := int64(len(frac)) + precision := max(int64(len(whole))+scale, 1) + return &ast.TypeCast{ + Arg: &ast.A_Const{Val: &ast.Float{Str: value}, Location: c.loc(n)}, + TypeName: &ast.TypeName{Name: "decimal", Typmods: appendTypmod(appendTypmod(nil, + &ast.A_Const{Val: &ast.Integer{Ival: precision}}), &ast.A_Const{Val: &ast.Integer{Ival: scale}})}, + Location: c.loc(n), + } +} + // namedCall is a call of name with args, for a function the parser gives a // node of its own, as LEFT and RIGHT, which are keywords too. func (c *cc) namedCall(name string, args []tsql.ScalarExpression, n tsql.Node) *ast.FuncCall { From 2ffa47b54db2255b82353da659f268ebea826381 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:09:19 -0800 Subject: [PATCH 64/74] golang: map SQL Server decimal to decimal.Decimal and money to mssql.Money decimal, numeric, money and smallmoney mapped to string, leaving each caller to parse it. They now map to shopspring's decimal, which go-mssqldb already depends on and sends as a decimal, as ClickHouse's decimals map, and money to the driver's Money over it, which it sends as money. A generic type's argument brings its package's import. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/codegen/golang/imports.go | 4 +++- internal/codegen/golang/mssql_type.go | 12 ++++++++---- .../endtoend/testdata/core_types/mssql/go/models.go | 9 +++++---- .../testdata/core_types/mssql/go/query.sql.go | 13 ++++++++----- .../testdata/mssql_output_clause/mssql/go/models.go | 4 +++- 5 files changed, 27 insertions(+), 15 deletions(-) diff --git a/internal/codegen/golang/imports.go b/internal/codegen/golang/imports.go index 62b59ba7c1..092893fa32 100644 --- a/internal/codegen/golang/imports.go +++ b/internal/codegen/golang/imports.go @@ -244,7 +244,9 @@ func buildImports(options *opts.Options, engine string, queries []Query, uses fu // decimal.Decimal must not pull in shopspring's as well. if usesDriverTypes(engine) { for qualifier, path := range driverTypes { - if uses(qualifier) && !overrideHasQualifier(overrideTypes, qualifier) { + // A generic type's argument needs its package too, as + // mssql.Money[decimal.Decimal] does. + if (uses(qualifier) || uses("mssql.Money["+qualifier)) && !overrideHasQualifier(overrideTypes, qualifier) { pkg[ImportSpec{Path: path}] = struct{}{} } } diff --git a/internal/codegen/golang/mssql_type.go b/internal/codegen/golang/mssql_type.go index 94492f58e9..06fb428422 100644 --- a/internal/codegen/golang/mssql_type.go +++ b/internal/codegen/golang/mssql_type.go @@ -7,8 +7,9 @@ import ( // mssqlType maps a SQL Server type to the Go type // github.com/microsoft/go-mssqldb hands database/sql for it. Exact numerics -// come back as their decimal text, so they map to string the way -// PostgreSQL's numeric does under database/sql. A uniqueidentifier maps to +// map to shopspring's decimal, which the driver sends as a decimal, and +// money to the driver's Money over it, which it sends as money. A +// uniqueidentifier maps to // the driver's own type, which keeps SQL Server's byte order straight. An // alias type created with CREATE TYPE ... FROM is reported by its own name, // which the catalog does not yet resolve to its base, so it maps to any @@ -35,8 +36,11 @@ func mssqlType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.C case "bit": return null("bool", "sql.NullBool") - case "decimal", "numeric", "money", "smallmoney": - return null("string", "sql.NullString") + case "decimal", "numeric": + return null("decimal.Decimal", "decimal.NullDecimal") + + case "money", "smallmoney": + return null("mssql.Money[decimal.Decimal]", "mssql.Money[decimal.NullDecimal]") case "float": return null("float64", "sql.NullFloat64") diff --git a/internal/endtoend/testdata/core_types/mssql/go/models.go b/internal/endtoend/testdata/core_types/mssql/go/models.go index db1ac4d38e..259bc0ec59 100644 --- a/internal/endtoend/testdata/core_types/mssql/go/models.go +++ b/internal/endtoend/testdata/core_types/mssql/go/models.go @@ -8,13 +8,14 @@ import ( "database/sql" "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" ) type Thing struct { ID int64 - Price string - Amount sql.NullString - Plain sql.NullString + Price decimal.Decimal + Amount decimal.NullDecimal + Plain decimal.NullDecimal Body sql.NullString Title sql.NullString Code sql.NullString @@ -28,7 +29,7 @@ type Thing struct { F sql.NullFloat64 F53 sql.NullFloat64 R sql.NullFloat64 - M sql.NullString + M mssql.Money[decimal.NullDecimal] B sql.NullBool U mssql.NullUniqueIdentifier X sql.NullString diff --git a/internal/endtoend/testdata/core_types/mssql/go/query.sql.go b/internal/endtoend/testdata/core_types/mssql/go/query.sql.go index 1645f7911b..5ab804ada8 100644 --- a/internal/endtoend/testdata/core_types/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/core_types/mssql/go/query.sql.go @@ -9,6 +9,9 @@ import ( "context" "database/sql" "time" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" ) const allTypes = `-- name: AllTypes :many @@ -91,21 +94,21 @@ WHERE CAST(@a AS DECIMAL(5,2)) > 0 ` type CastsParams struct { - A string + A decimal.Decimal B string C string D time.Time - E string + E mssql.Money[decimal.Decimal] F float32 G string } type CastsRow struct { - A sql.NullString + A decimal.NullDecimal B sql.NullString C sql.NullString D sql.NullTime - E sql.NullString + E mssql.Money[decimal.NullDecimal] F sql.NullFloat64 G sql.NullString } @@ -139,7 +142,7 @@ WHERE price = @price AND body = @body AND phone = @phone AND offset_at = @offset ` type ParamsParams struct { - Price string + Price decimal.Decimal Body sql.NullString Phone any OffsetAt sql.NullTime diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go index bc401e8242..d83c9edeab 100644 --- a/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go @@ -6,6 +6,8 @@ package querytest import ( "database/sql" + + "github.com/shopspring/decimal" ) type Author struct { @@ -18,5 +20,5 @@ type Book struct { ID int64 AuthorID int64 Title string - Price sql.NullString + Price decimal.NullDecimal } From c899fe524d2e6bda10d6ee7c86a7f8c451014876 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:10:52 -0800 Subject: [PATCH 65/74] golang: map a nullable uniqueidentifier to *mssql.UniqueIdentifier go-mssqldb sends a NULL mssql.NullUniqueIdentifier passed by value as a GUID of length 0 followed by 16 bytes, which SQL Server rejects with error 8009, so a generated query could not pass NULL for one. A nil *mssql.UniqueIdentifier it sends as NULL, and scans NULL into, so a nullable uniqueidentifier now maps to that. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/codegen/golang/mssql_type.go | 5 ++++- internal/endtoend/testdata/core_types/mssql/go/models.go | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/internal/codegen/golang/mssql_type.go b/internal/codegen/golang/mssql_type.go index 06fb428422..d487d7c557 100644 --- a/internal/codegen/golang/mssql_type.go +++ b/internal/codegen/golang/mssql_type.go @@ -58,7 +58,10 @@ func mssqlType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.C return null("time.Time", "sql.NullTime") case "uniqueidentifier": - return null("mssql.UniqueIdentifier", "mssql.NullUniqueIdentifier") + // go-mssqldb sends a NULL mssql.NullUniqueIdentifier passed by value + // as a malformed GUID, which SQL Server rejects with error 8009; a + // nil *mssql.UniqueIdentifier it sends as NULL. + return null("mssql.UniqueIdentifier", "*mssql.UniqueIdentifier") case "geography", "geometry", "hierarchyid", "vector": return "[]byte" diff --git a/internal/endtoend/testdata/core_types/mssql/go/models.go b/internal/endtoend/testdata/core_types/mssql/go/models.go index 259bc0ec59..0aa73a328a 100644 --- a/internal/endtoend/testdata/core_types/mssql/go/models.go +++ b/internal/endtoend/testdata/core_types/mssql/go/models.go @@ -31,7 +31,7 @@ type Thing struct { R sql.NullFloat64 M mssql.Money[decimal.NullDecimal] B sql.NullBool - U mssql.NullUniqueIdentifier + U *mssql.UniqueIdentifier X sql.NullString J sql.NullString Sv any From fccb542f0756a0859119de116aae0e5c787fe7d7 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:28:29 -0800 Subject: [PATCH 66/74] mssql: report a placeholder the converter drops A placeholder in a construct the converter does not follow, as TABLESAMPLE (@n PERCENT) or CONVERT's style, was dropped from the query's parameters, generating code that passed the query too few arguments. Every @name in a named query's text, outside strings, quoted names and comments, must now be one of its parameters, and one that is not is reported where it is. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../mssql/exec.json | 1 + .../mssql/query.sql | 5 ++ .../mssql/schema.sql | 1 + .../mssql/sqlc.yaml | 10 +++ .../mssql/stderr.txt | 2 + internal/engine/mssql/parse.go | 76 +++++++++++++++++++ 6 files changed, 95 insertions(+) create mode 100644 internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml create mode 100644 internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql new file mode 100644 index 0000000000..6376e1f909 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Ids :many +SELECT id FROM t WHERE name = '@not_a_param' /* @nor_this */ AND id > @min; + +-- name: Sample :many +SELECT id FROM t WITH (INDEX(@ix)); diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql new file mode 100644 index 0000000000..15ae02025c --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL); diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt new file mode 100644 index 0000000000..8303d18af0 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:30: placeholder @ix is not supported where it is used diff --git a/internal/engine/mssql/parse.go b/internal/engine/mssql/parse.go index 174e120c19..681888dcd2 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -70,6 +70,12 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { continue } + if namedQuery.Match(blob[loc:end]) { + if err := checkPlaceholders(blob, start, end, converter.namedParams); err != nil { + return nil, err + } + } + stmts = append(stmts, ast.Statement{ Raw: &ast.RawStmt{ Stmt: out, @@ -88,6 +94,76 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { // style. var namedQuery = regexp.MustCompile(`(?m)^\s*(--|/\*)\s*name:\s*\S+`) +// checkPlaceholders reports a placeholder in a query's text that did not +// become one of its parameters, which a construct the converter does not +// follow drops, leaving generated code that passes the query too few +// arguments. +func checkPlaceholders(blob []byte, start, end int, params map[string]namedParam) error { + for _, p := range placeholders(blob[start:end]) { + if _, ok := params[strings.ToLower(p.name)]; !ok { + return &sqlerr.Error{ + Message: fmt.Sprintf("placeholder @%s is not supported where it is used", p.name), + Location: start + p.offset, + } + } + } + return nil +} + +type placeholder struct { + name string + offset int +} + +// placeholders are the @name placeholders in sql, leaving out @@ system +// variables and anything inside a string, a quoted or bracketed +// identifier or a comment. +func placeholders(sql []byte) []placeholder { + var out []placeholder + skipTo := func(i int, close string) int { + if j := bytes.Index(sql[i:], []byte(close)); j >= 0 { + return i + j + len(close) + } + return len(sql) + } + for i := 0; i < len(sql); { + switch c := sql[i]; { + case c == '\'' || c == '"': + // A doubled quote inside is an escaped one, which the scan + // steps over as the end of one string and the start of the + // next. + i = skipTo(i+1, string(c)) + case c == '[': + i = skipTo(i+1, "]") + case c == '-' && i+1 < len(sql) && sql[i+1] == '-': + i = skipTo(i, "\n") + case c == '/' && i+1 < len(sql) && sql[i+1] == '*': + i = skipTo(i+2, "*/") + case c == '@': + j := i + 1 + for j < len(sql) && isNameByte(sql[j]) { + j++ + } + if i+1 < len(sql) && sql[i+1] == '@' { + i = j + continue + } + if j > i+1 { + out = append(out, placeholder{name: string(sql[i+1 : j]), offset: i}) + } + i = j + default: + i++ + } + } + return out +} + +func isNameByte(b byte) bool { + return b == '_' || b == '#' || b == '$' || b == '@' || + 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' || '0' <= b && b <= '9' || b >= utf8.RuneSelf +} + // byteOffsets returns a function mapping a UTF-16 code-unit offset — how // teesql records source spans, mirroring ScriptDom — to a byte offset in // blob. For ASCII input the two are identical and the identity is returned. From f59fb16ef8dbad52ccd177de4d00b4499196a988 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:31:00 -0800 Subject: [PATCH 67/74] mssql: keep the placeholder in CONVERT's style A style given as a placeholder, as CONVERT(nvarchar(30), at, @style), was dropped. It is now passed as an int, through a function returning the converted value, which may then be NULL; a literal style is left as it was. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_convert_style/mssql/exec.json | 5 +++ .../analyze_convert_style/mssql/query.sql | 2 + .../analyze_convert_style/mssql/schema.sql | 1 + .../analyze_convert_style/mssql/stdout.json | 42 +++++++++++++++++++ internal/engine/mssql/convert.go | 12 +++++- internal/engine/mssql/dialect/functions.jsonl | 1 + 6 files changed, 62 insertions(+), 1 deletion(-) create mode 100644 internal/endtoend/testdata/analyze_convert_style/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_convert_style/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/exec.json b/internal/endtoend/testdata/analyze_convert_style/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql b/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql new file mode 100644 index 0000000000..3e4f34f892 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Styled :many +SELECT CONVERT(nvarchar(30), at, @style) AS styled, CONVERT(varchar(10), at, 23) AS fixed FROM t; diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql b/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql new file mode 100644 index 0000000000..64963bfc13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2 NOT NULL); diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json b/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json new file mode 100644 index 0000000000..e8ba8dfda0 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json @@ -0,0 +1,42 @@ +[ + { + "name": "Styled", + "cmd": ":many", + "columns": [ + { + "name": "styled", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + }, + { + "name": "fixed", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "style", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index f1da1c4a8b..81cdc1a88a 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -920,8 +920,18 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.TryParseCall: return c.parseCall(e.StringValue, e.Culture, e.DataType, true, e) case *tsql.ConvertCall: + arg := c.convertScalarExpression(e.Parameter) + // A style given as other than a literal, as @style, is an int + // passed through "convert style", which may return NULL. + if _, literal := e.Style.(*tsql.IntegerLiteral); e.Style != nil && !literal { + arg = &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: "convert style"}}}, + Args: &ast.List{Items: []ast.Node{arg, &ast.TypeCast{Arg: c.convertScalarExpression(e.Style), TypeName: &ast.TypeName{Name: "int"}}}}, + Location: c.loc(e), + } + } return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), + Arg: arg, TypeName: dataTypeName(e.DataType), Location: c.loc(e), } diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index 5e4011e89a..9396dad946 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -419,3 +419,4 @@ {"name": "regexp_count", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} {"name": "vector_distance", "args": [{"type": "varchar"}, {"type": "vector"}, {"type": "vector"}], "returns": "float", "nullable": true} {"name": "trim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$2"} +{"name": "convert style", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} From 99b6601aa89e4f6614444fa865884c8d5be36c1c Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:31:00 -0800 Subject: [PATCH 68/74] mssql: keep the placeholders of TABLESAMPLE TABLESAMPLE (@n PERCENT) and REPEATABLE (@seed) dropped their placeholders. They are now analyzed with the query's WHERE clause, as FOR SYSTEM_TIME's are: a percentage as a float, a count of rows and a seed as a bigint. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../analyze_tablesample/mssql/exec.json | 5 ++ .../analyze_tablesample/mssql/query.sql | 5 ++ .../analyze_tablesample/mssql/schema.sql | 1 + .../analyze_tablesample/mssql/stdout.json | 69 +++++++++++++++++++ internal/engine/mssql/convert.go | 16 +++++ 5 files changed, 96 insertions(+) create mode 100644 internal/endtoend/testdata/analyze_tablesample/mssql/exec.json create mode 100644 internal/endtoend/testdata/analyze_tablesample/mssql/query.sql create mode 100644 internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql create mode 100644 internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json b/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql b/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql new file mode 100644 index 0000000000..7c8561d078 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Sampled :many +SELECT id FROM t TABLESAMPLE (@pct PERCENT) WHERE id > @min; + +-- name: SampledRows :many +SELECT id FROM t TABLESAMPLE SYSTEM (@n ROWS) REPEATABLE (@seed); diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql b/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql new file mode 100644 index 0000000000..64963bfc13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2 NOT NULL); diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json b/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json new file mode 100644 index 0000000000..9ea3c11619 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json @@ -0,0 +1,69 @@ +[ + { + "name": "Sampled", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "t" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pct", + "type": { + "name": "float" + } + } + }, + { + "number": 2, + "column": { + "name": "min", + "type": { + "name": "int" + }, + "table": "t" + } + } + ] + }, + { + "name": "SampledRows", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "t" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "bigint" + } + } + }, + { + "number": 2, + "column": { + "name": "seed", + "type": { + "name": "bigint" + } + } + } + ] + } +] diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index 81cdc1a88a..a4c7d4f35f 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -452,6 +452,22 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { } } } + // TABLESAMPLE takes a percentage as a float and a count of rows + // or a REPEATABLE seed as a bigint. + if ts := t.TableSampleClause; ts != nil { + size := "float" + if ts.TableSampleClauseOption == "Rows" { + size = "bigint" + } + for _, e := range []struct { + expr tsql.ScalarExpression + typ string + }{{ts.SampleNumber, size}, {ts.RepeatSeed, "bigint"}} { + if e.expr != nil { + c.fromExprs = append(c.fromExprs, &ast.TypeCast{Arg: c.convertScalarExpression(e.expr), TypeName: &ast.TypeName{Name: e.typ}}) + } + } + } return rv case *tsql.QueryDerivedTable: sub := &ast.RangeSubselect{ From 14a031f0144da7c394bbf14b779875549fea98f4 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:52:47 -0800 Subject: [PATCH 69/74] core: type a set operation column of an argument-free type as its family A column of UNION, INTERSECT or EXCEPT whose combined type has no arguments, as a string literal's varchar or decimal arithmetic's decimal, was looked up as a declared type, which takes the dialect's defaults: varchar(1) and decimal(18,0). It is now its family. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/setop.go | 7 +++++++ .../testdata/analyze_set_operations/mssql/query.sql | 3 +++ .../analyze_set_operations/mssql/stdout.json | 13 +++++++++++++ 3 files changed, 23 insertions(+) diff --git a/internal/core/analyzer/setop.go b/internal/core/analyzer/setop.go index 04e8060414..52b83ee802 100644 --- a/internal/core/analyzer/setop.go +++ b/internal/core/analyzer/setop.go @@ -66,6 +66,13 @@ func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r exprType) ex case len(out.Args) == 1 && len(loser.Args) == 1 && a.sameCategory(lt.Name, rt.Name): out.Args[0] = widerArg(out.Args[0], loser.Args[0]) } + // A type with no arguments is its family. Looked up as a declaration + // it would take the dialect's defaults, as varchar is varchar(1). + if len(out.Args) == 0 { + if oid, err := a.cat.TypeOID(out.Name); err == nil { + return exprType{typeOID: oid} + } + } return a.lookupType(out) } diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql index f52cdad03c..344b803714 100644 --- a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql @@ -27,3 +27,6 @@ UNION ALL SELECT amount FROM ledger UNION ALL SELECT flag FROM ledger; + +-- name: LiteralUnion :many +SELECT 'active' AS status UNION ALL SELECT 'inactive'; diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json index c7cd695f18..97efa9f313 100644 --- a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json @@ -166,5 +166,18 @@ } ], "params": [] + }, + { + "name": "LiteralUnion", + "cmd": ":many", + "columns": [ + { + "name": "status", + "type": { + "name": "varchar" + } + } + ], + "params": [] } ] From a13cdbc068eda807520dd32693fa40b2f8025e4e Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:33:37 -0800 Subject: [PATCH 70/74] core: stop pairing INSERT ... SELECT items with columns after a star A placeholder selected by INSERT ... SELECT took the type of the column at its position, but a star before it selects any number of columns, so INSERT INTO t (id, name, at, n) SELECT t2.*, @n typed @n as name. Items after a star are no longer paired. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/core/analyzer/dml.go | 8 ++++++-- .../analyze_insert_select_params/mssql/query.sql | 3 +++ .../analyze_insert_select_params/mssql/stdout.json | 13 +++++++++++++ 3 files changed, 22 insertions(+), 2 deletions(-) diff --git a/internal/core/analyzer/dml.go b/internal/core/analyzer/dml.go index 9a158f474b..51975dd5b9 100644 --- a/internal/core/analyzer/dml.go +++ b/internal/core/analyzer/dml.go @@ -146,12 +146,16 @@ func (a *analyzer) bindInsertValues(n ast.Node, rel scopeRel, targets []core.Cla // the statement's result, but the query still holds placeholders. if sel.ValuesLists == nil { // A placeholder selected as it is takes the type of the column it - // is inserted into, as one in VALUES does. + // is inserted into, as one in VALUES does. A star selects any + // number of columns, so the items after one are not paired. if sel.Op == ast.None { for i, item := range listItems(sel.TargetList) { rt, ok := item.(*ast.ResTarget) if !ok || i >= len(targets) { - continue + break + } + if cr, ok := rt.Val.(*ast.ColumnRef); ok && isStar(flattenFields(cr.Fields)) { + break } if p, ok := rt.Val.(*ast.ParamRef); ok { a.inferParam(p, columnType(rel, targets[i])) diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql index 679a148aab..402d9d8f61 100644 --- a/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql @@ -3,3 +3,6 @@ INSERT INTO t (id, name, at, n) SELECT @a, @b, @c, @d; -- name: CopyRow :exec INSERT INTO t (id, name, at, n) SELECT @a, name, at, n + @inc FROM t WHERE id = @src; + +-- name: CopyWithStar :exec +INSERT INTO t (id, name, at, n) SELECT t2.*, @n FROM (SELECT id, name, at FROM t) t2; diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json index 1886cd3009..46f15394ca 100644 --- a/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json @@ -93,5 +93,18 @@ } } ] + }, + { + "name": "CopyWithStar", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "n" + } + } + ] } ] From 38f9390bf79f3cf7c67581aa2f0f6011794a37d8 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:35:27 -0800 Subject: [PATCH 71/74] mssql: leave sqlc.embed out of the @name check sqlc.embed names a table, not a parameter, so sqlc.embed("order details") was rejected as an invalid @name. Only sqlc.arg, narg and slice are checked now. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/sql/preprocess/scan.go | 5 ++-- .../mssql/embed_quoted_table/input.sql | 1 + .../mssql/embed_quoted_table/output.sql | 1 + .../mssql/embed_quoted_table/side_table.json | 24 +++++++++++++++++++ 4 files changed, 29 insertions(+), 2 deletions(-) create mode 100644 internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json diff --git a/internal/sql/preprocess/scan.go b/internal/sql/preprocess/scan.go index feafe91ddc..59c6825f8b 100644 --- a/internal/sql/preprocess/scan.go +++ b/internal/sql/preprocess/scan.go @@ -140,8 +140,9 @@ func (l *lexer) sqlcCall(start, afterSqlc int) (occurrence, int, bool) { return occ, occ.end, true } // A dialect that binds @name writes the name into the query, so it has - // to read back as one parameter: @user-id would be a subtraction. - if l.d.Style == StyleAt && !isParamName(name) { + // to read back as one parameter: @user-id would be a subtraction. An + // embed names a table, not a parameter. + if l.d.Style == StyleAt && fn != "embed" && !isParamName(name) { occ.err = &sqlerr.Error{ Message: fmt.Sprintf("parameter name %q passed to sqlc.%s is not a valid @name; use letters, digits and underscores", name, fn), Location: start, diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql new file mode 100644 index 0000000000..1d03b5f520 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql @@ -0,0 +1 @@ +SELECT sqlc.embed("order details") FROM [order details] WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql new file mode 100644 index 0000000000..5554ca972b --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql @@ -0,0 +1 @@ +SELECT "order details".* FROM [order details] WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json new file mode 100644 index 0000000000..4baa50e0c2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 61, + "dollar": true, + "params": [ + { + "number": 1, + "location": 57, + "origin": 67, + "name": "id", + "named": true + } + ], + "embeds": [ + { + "table": "order details", + "location": 7, + "origin": 7, + "orig": "sqlc.embed(\"order details\")" + } + ] + } +] From cbc8adc7aa3078938cbd9ff9cd6fb712f0308b0c Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:35:27 -0800 Subject: [PATCH 72/74] mssql: read a placeholder's name through #, $ and @ SQL Server's names go on through #, $ and @ after the first character, but the preprocessor stopped at them, so @a and @a#b were both read as @a and given one number, and generated code bound only one of them. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/sql/preprocess/scan.go | 5 ++++ .../testdata/mssql/names_with_hash/input.sql | 1 + .../testdata/mssql/names_with_hash/output.sql | 1 + .../mssql/names_with_hash/side_table.json | 30 +++++++++++++++++++ 4 files changed, 37 insertions(+) create mode 100644 internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql create mode 100644 internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql create mode 100644 internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json diff --git a/internal/sql/preprocess/scan.go b/internal/sql/preprocess/scan.go index 59c6825f8b..026899ed58 100644 --- a/internal/sql/preprocess/scan.go +++ b/internal/sql/preprocess/scan.go @@ -36,6 +36,11 @@ func (l *lexer) scan(start, end int) []occurrence { // @@name is a system function, such as SQL Server's @@ROWCOUNT. case c == '@' && l.d.AtSign && isIdentStart(l.at(i+1)) && l.at(i-1) != '@': j := l.identEnd(i + 1) + // A SQL Server name goes on through #, $ and @, so @a and @a#b + // are two parameters. + for l.d.Style == StyleAt && j < len(l.src) && (isIdentPart(l.src[j]) || strings.IndexByte("#$@", l.src[j]) >= 0) { + j++ + } out = append(out, occurrence{ kind: kindArg, start: i, diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql b/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql new file mode 100644 index 0000000000..4cd1e4dc34 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id = @a AND parent = @a#b AND other = @a$c; diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql b/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql new file mode 100644 index 0000000000..4cd1e4dc34 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id = @a AND parent = @a#b AND other = @a$c; diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json b/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json new file mode 100644 index 0000000000..fe5e7ecea4 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json @@ -0,0 +1,30 @@ +[ + { + "start": 0, + "end": 70, + "dollar": true, + "params": [ + { + "number": 1, + "location": 32, + "origin": 32, + "name": "a", + "named": true + }, + { + "number": 2, + "location": 48, + "origin": 48, + "name": "a#b", + "named": true + }, + { + "number": 3, + "location": 65, + "origin": 65, + "name": "a$c", + "named": true + } + ] + } +] From 600b393b0677af3238f4953619b94effc10c82ac Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:36:44 -0800 Subject: [PATCH 73/74] mssql: measure a star qualifier with escaped quotes as written A star qualified by a name that needs quoting was measured from the name as sqlc quotes it for output, so "a""b".* read as [a"b] measured short and left the star in the query, and "x]y".* measured long. Each quoted form is now built from the name itself, doubling its quotes. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/expand.go | 4 +- .../mssql/exec.json | 1 + .../mssql/go/db.go | 31 +++++++ .../mssql/go/models.go | 14 +++ .../mssql/go/query.sql.go | 91 +++++++++++++++++++ .../mssql/query.sql | 8 ++ .../mssql/schema.sql | 1 + .../mssql/sqlc.yaml | 10 ++ 8 files changed, 158 insertions(+), 2 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml diff --git a/internal/compiler/expand.go b/internal/compiler/expand.go index 64ed0693d8..f8073ae4ff 100644 --- a/internal/compiler/expand.go +++ b/internal/compiler/expand.go @@ -108,9 +108,9 @@ func (c *Compiler) starOldFunc(parts []string) func(string) int { } 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 := `"` + o + `"`; strings.HasPrefix(s[length:], 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) diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go new file mode 100644 index 0000000000..4167d53357 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go @@ -0,0 +1,14 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int32 + Name sql.NullString +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go new file mode 100644 index 0000000000..6a06f8caa8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go @@ -0,0 +1,91 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" +) + +const a = `-- name: A :many +SELECT [a"b].id, [a"b].name FROM authors AS "a""b"; +` + +func (q *Queries) A(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, a) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const b = `-- name: B :many +SELECT [x]]y].id, [x]]y].name FROM authors AS "x]y"; +` + +func (q *Queries) B(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, b) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const c = `-- name: C :many +SELECT [x]]y].id, [x]]y].name FROM authors AS [x]]y]; +` + +func (q *Queries) C(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, c) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql new file mode 100644 index 0000000000..37705849ae --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: A :many +SELECT "a""b".* FROM authors AS "a""b"; + +-- name: B :many +SELECT "x]y".* FROM authors AS "x]y"; + +-- name: C :many +SELECT [x]]y].* FROM authors AS [x]]y]; diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql new file mode 100644 index 0000000000..531179cece --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(10) NULL); diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" From f2dbfc755198df446f5d8ee44098ba35f79a2f69 Mon Sep 17 00:00:00 2001 From: EliSauder <24995216+EliSauder@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:38:34 -0800 Subject: [PATCH 74/74] mssql: embed a table only when its columns are as nullable as the table's sqlc.embed(b) on the optional side of an outer join folded b's columns into the Book model, whose fields cannot hold NULL, so scanning a row with no match failed. A table is now embedded only when each column is as nullable as the table's, and otherwise its columns stay flat. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- internal/compiler/parse_core.go | 5 +- .../mssql_embed_outer_join/mssql/exec.json | 1 + .../mssql_embed_outer_join/mssql/go/db.go | 31 +++++++++++ .../mssql_embed_outer_join/mssql/go/models.go | 20 ++++++++ .../mssql/go/query.sql.go | 51 +++++++++++++++++++ .../mssql_embed_outer_join/mssql/query.sql | 2 + .../mssql_embed_outer_join/mssql/schema.sql | 2 + .../mssql_embed_outer_join/mssql/sqlc.yaml | 10 ++++ 8 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql create mode 100644 internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml diff --git a/internal/compiler/parse_core.go b/internal/compiler/parse_core.go index 5679f39dd6..2ad64cb77b 100644 --- a/internal/compiler/parse_core.go +++ b/internal/compiler/parse_core.go @@ -148,7 +148,8 @@ func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, } // isWholeTable reports whether cols are every column of one table, in the -// table's order. +// 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 { @@ -175,7 +176,7 @@ func isWholeTable(cat *core.Catalog, cols []*Column) bool { if tc.Hidden { continue } - if i >= len(cols) || cols[i].Table == nil || *cols[i].Table != *table || cols[i].OriginalName != tc.Name { + 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++ diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go new file mode 100644 index 0000000000..33cf3d5142 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go @@ -0,0 +1,20 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int32 + Name string +} + +type Book struct { + ID int32 + AuthorID int32 + Title sql.NullString +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go new file mode 100644 index 0000000000..2463659348 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go @@ -0,0 +1,51 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const authorBooks = `-- name: AuthorBooks :many +SELECT a.id, a.name, b.id, b.author_id, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type AuthorBooksRow struct { + Author Author + ID sql.NullInt32 + AuthorID sql.NullInt32 + Title sql.NullString +} + +func (q *Queries) AuthorBooks(ctx context.Context) ([]AuthorBooksRow, error) { + rows, err := q.db.QueryContext(ctx, authorBooks) + if err != nil { + return nil, err + } + defer rows.Close() + var items []AuthorBooksRow + for rows.Next() { + var i AuthorBooksRow + if err := rows.Scan( + &i.Author.ID, + &i.Author.Name, + &i.ID, + &i.AuthorID, + &i.Title, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql new file mode 100644 index 0000000000..bd127e839d --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: AuthorBooks :many +SELECT sqlc.embed(a), sqlc.embed(b) FROM authors a LEFT JOIN books b ON b.author_id = a.id; diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql new file mode 100644 index 0000000000..7aaba24c5a --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(10) NOT NULL); +CREATE TABLE books (id INT NOT NULL, author_id INT NOT NULL, title NVARCHAR(20) NULL); diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql"