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 e96d8dbe2a..5c72b1c382 100644 --- a/internal/core/schema/schema.go +++ b/internal/core/schema/schema.go @@ -47,8 +47,16 @@ 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: - 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 @@ -160,7 +168,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 +194,69 @@ 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, 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) + } + } + 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 +305,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 } @@ -328,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") @@ -413,6 +511,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_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/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..b4108d6c79 --- /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, precise, price_text, 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..109a0ba7f7 --- /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'!'), + bio_label AS (bio + N'?'), + 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 new file mode 100644 index 0000000000..3ceb0ff480 --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -0,0 +1,298 @@ +[ + { + "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": "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": { + "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": "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": { + "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/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/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/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/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/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/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 bdef335bc6..90334715bf 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -63,13 +63,55 @@ 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.ExecuteStatement: + return c.convertExecuteStatement(n) + case *tsql.CreateSequenceStatement: + 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: + 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. @@ -644,6 +686,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{ @@ -1074,6 +1124,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 +1174,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. @@ -1184,6 +1271,240 @@ 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, + } +} + +// 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}}}, + } +} + +// 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 != "" { + 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 +// 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. +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. +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) 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 } 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 )