From 07566c8536f6bdda77699f66fe24184113987dad 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 1/9] feat(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 | 14 + .../mssql/stdout.json | 240 ++++++++++++++++++ internal/engine/mssql/convert.go | 37 +++ internal/sql/ast/constr_type.go | 5 +- 7 files changed, 381 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..3369236eca --- /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, bio_label, cost, 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..1ef21bd2ba --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql @@ -0,0 +1,14 @@ +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'!'), + bio_label AS (bio + N'?'), + cost AS (CAST(price AS decimal(10,2))) +); + +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..693943a49a --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -0,0 +1,240 @@ +[ + { + "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": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "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": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "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 bdef335bc6..225960ed15 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1074,6 +1074,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 @@ -1110,6 +1124,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 6ae8fb1d5acd8932c1ed6ffe25ef2ead54c47718 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 2/9] feat(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 225960ed15..7a74ba7cbf 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -65,11 +65,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 e49d9b22ab0728cec57c7fa12a88469e11cd94f3 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 3/9] fix(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 3369236eca..b4108d6c79 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, bio_label, cost, extra +SELECT total, doubled, doubled_nn, label, bio_label, cost, 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 1ef21bd2ba..109a0ba7f7 100644 --- a/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql @@ -8,7 +8,9 @@ CREATE TABLE authors ( doubled_nn AS (price * 2) PERSISTED NOT NULL, label AS (name + N'!'), bio_label AS (bio + N'?'), - cost AS (CAST(price AS decimal(10,2))) + cost AS (CAST(price AS decimal(10,2))), + 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 693943a49a..3ceb0ff480 100644 --- a/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -58,6 +58,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": { @@ -178,6 +207,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 0995c0a85e23b5f4a4bb965c95fdf869157d9ee1 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 4/9] feat(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 7a74ba7cbf..e0e3227f7f 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -63,6 +63,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: @@ -1253,6 +1255,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 4a2d38bde8430bf5f31492d55c1581e043c9c482 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 5/9] feat(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 e0e3227f7f..919c663087 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -65,6 +65,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: @@ -1255,6 +1257,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 4bbce3455d8399265c428da398367c6958a5e826 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 6/9] feat(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 919c663087..99aedc043d 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1257,6 +1257,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 e222708ece..51467c3d1c 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -47,6 +47,11 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { converter := &cc{toByte: toByte} out := converter.convert(stmt) if _, ok := out.(*ast.TODO); ok { + 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 bbda21d2bcfb66a67ddfe19d8ae9e26344d4f2a0 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 7/9] feat(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 99aedc043d..acc4906212 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -67,6 +67,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: @@ -680,6 +682,14 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Subselect: c.convertQueryExpression(e.QueryExpression), 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.ParameterlessCall: return &ast.FuncCall{ Funcname: &ast.List{ @@ -1257,6 +1267,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 475e15b209998299ca8372fad436a49b8127f0f6 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 8/9] feat(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 35def91fd7..b2f66be518 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 +} + // 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 { 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 acc4906212..90ce2054be 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -69,6 +69,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertExecuteStatement(n) case *tsql.CreateSequenceStatement: return c.convertCreateSequenceStatement(n) + case *tsql.CreateSynonymStatement: + return c.convertCreateSynonymStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) case *tsql.CreateViewStatement: @@ -1286,6 +1288,24 @@ func (c *cc) convertCreateSequenceStatement(n *tsql.CreateSequenceStatement) 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}}}, + } +} + func sequenceFunc(name *tsql.SchemaObjectName) string { tn := parseTableName(name) if tn.Schema != "" { From 586e335d698079b726bb8e420975828618012203 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 9/9] feat(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 b2f66be518..5c72b1c382 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 90ce2054be..90334715bf 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -71,6 +71,8 @@ func (c *cc) convert(node tsql.Node) ast.Node { return c.convertCreateSequenceStatement(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: @@ -1306,6 +1308,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, + } +} + func sequenceFunc(name *tsql.SchemaObjectName) string { tn := parseTableName(name) if tn.Schema != "" {