diff --git a/docs/reference/macros.md b/docs/reference/macros.md index 54d44ed5c9..fb8ac2ebe8 100644 --- a/docs/reference/macros.md +++ b/docs/reference/macros.md @@ -115,5 +115,8 @@ WHERE age IN (/*SLICE:ages*/?) Since the `/*SLICE:ages*/` placeholder is dynamically replaced on a per-query basis, this macro can't be used with prepared statements. +On SQL Server the placeholder is `/*SLICE:ages*/@ages`, and each value is bound +to its own `@p` parameter, the name go-mssqldb gives an unnamed argument. + See a full example in [Passing a slice as a parameter to a query](../howto/select.md#mysql-and-sqlite). diff --git a/docs/reference/query-annotations.md b/docs/reference/query-annotations.md index 4fabe05aae..57eed12d4c 100644 --- a/docs/reference/query-annotations.md +++ b/docs/reference/query-annotations.md @@ -77,6 +77,9 @@ func (q *Queries) InsertAuthor(ctx context.Context, name string) (int64, error) } ``` +SQL Server's driver reports no last insert ID, so `:execlastid` is not +supported there. Return the ID with `OUTPUT INSERTED.id` and `:one` instead. + ## `:many` The generated method will return a slice of records via diff --git a/internal/codegen/golang/gen.go b/internal/codegen/golang/gen.go index 725f5970cf..343bc123db 100644 --- a/internal/codegen/golang/gen.go +++ b/internal/codegen/golang/gen.go @@ -212,6 +212,16 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum, tctx.SQLDriver = opts.SQLDriverGoSQLDriverMySQL } + // go-mssqldb never reports a last insert ID; SQL Server returns one with + // OUTPUT INSERTED. + if req.Settings.Engine == engineMSSQL { + for _, q := range queries { + if q.Cmd == metadata.CmdExecLastId { + return nil, fmt.Errorf("query %q: :execlastid is not supported for SQL Server, whose driver reports no last insert ID; use OUTPUT INSERTED. with :one", q.MethodName) + } + } + } + if tctx.UsesBatch && !tctx.SQLDriver.IsPGX() { return nil, errors.New(":batch* commands are only supported by pgx") } diff --git a/internal/codegen/golang/imports.go b/internal/codegen/golang/imports.go index e1370e48eb..092893fa32 100644 --- a/internal/codegen/golang/imports.go +++ b/internal/codegen/golang/imports.go @@ -244,7 +244,9 @@ func buildImports(options *opts.Options, engine string, queries []Query, uses fu // decimal.Decimal must not pull in shopspring's as well. if usesDriverTypes(engine) { for qualifier, path := range driverTypes { - if uses(qualifier) && !overrideHasQualifier(overrideTypes, qualifier) { + // A generic type's argument needs its package too, as + // mssql.Money[decimal.Decimal] does. + if (uses(qualifier) || uses("mssql.Money["+qualifier)) && !overrideHasQualifier(overrideTypes, qualifier) { pkg[ImportSpec{Path: path}] = struct{}{} } } @@ -439,9 +441,16 @@ func (i *importer) queryImports(filename string) fileImports { return false } - // A query bound by name passes sql.Named arguments. + // A query bound by name passes sql.Named arguments, except for its + // slices, whose values it binds to numbered placeholders. for _, q := range gq { - if q.Arg.NamedArgs && !q.Arg.isEmpty() { + if !q.Arg.NamedArgs || q.Arg.isEmpty() { + continue + } + if q.Arg.HasSqlcSlices() { + std["strconv"] = struct{}{} + } + if q.Arg.hasNamedArg() { std["database/sql"] = struct{}{} } } @@ -454,6 +463,7 @@ func (i *importer) queryImports(filename string) fileImports { if sqlcSliceScan() && !sqlpkg.IsPGX() { std["strings"] = struct{}{} } + if sliceScan() && usesPqArrays(i.Engine, sqlpkg) { pkg[ImportSpec{Path: "github.com/lib/pq"}] = struct{}{} } diff --git a/internal/codegen/golang/mssql_type.go b/internal/codegen/golang/mssql_type.go index 94492f58e9..d487d7c557 100644 --- a/internal/codegen/golang/mssql_type.go +++ b/internal/codegen/golang/mssql_type.go @@ -7,8 +7,9 @@ import ( // mssqlType maps a SQL Server type to the Go type // github.com/microsoft/go-mssqldb hands database/sql for it. Exact numerics -// come back as their decimal text, so they map to string the way -// PostgreSQL's numeric does under database/sql. A uniqueidentifier maps to +// map to shopspring's decimal, which the driver sends as a decimal, and +// money to the driver's Money over it, which it sends as money. A +// uniqueidentifier maps to // the driver's own type, which keeps SQL Server's byte order straight. An // alias type created with CREATE TYPE ... FROM is reported by its own name, // which the catalog does not yet resolve to its base, so it maps to any @@ -35,8 +36,11 @@ func mssqlType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.C case "bit": return null("bool", "sql.NullBool") - case "decimal", "numeric", "money", "smallmoney": - return null("string", "sql.NullString") + case "decimal", "numeric": + return null("decimal.Decimal", "decimal.NullDecimal") + + case "money", "smallmoney": + return null("mssql.Money[decimal.Decimal]", "mssql.Money[decimal.NullDecimal]") case "float": return null("float64", "sql.NullFloat64") @@ -54,7 +58,10 @@ func mssqlType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.C return null("time.Time", "sql.NullTime") case "uniqueidentifier": - return null("mssql.UniqueIdentifier", "mssql.NullUniqueIdentifier") + // go-mssqldb sends a NULL mssql.NullUniqueIdentifier passed by value + // as a malformed GUID, which SQL Server rejects with error 8009; a + // nil *mssql.UniqueIdentifier it sends as NULL. + return null("mssql.UniqueIdentifier", "*mssql.UniqueIdentifier") case "geography", "geometry", "hierarchyid", "vector": return "[]byte" diff --git a/internal/codegen/golang/query.go b/internal/codegen/golang/query.go index 6bd9b70e25..363ae6a0b0 100644 --- a/internal/codegen/golang/query.go +++ b/internal/codegen/golang/query.go @@ -157,6 +157,12 @@ func (v QueryValue) namedArg(name, expr string) string { return "sql.Named(" + strconv.Quote(name) + ", " + expr + ")" } +// NamedArgForField is the argument expr passed for a field of a query bound +// by name. +func (v QueryValue) NamedArgForField(f Field) string { + return v.namedArg(f.ParamName, v.VariableForField(f)) +} + func (v QueryValue) Params() string { if v.isEmpty() { return "" @@ -224,6 +230,20 @@ func (v QueryValue) HasSqlcSlices() bool { return false } +// hasNamedArg reports whether any parameter is passed as sql.Named, which a +// sqlc.slice() never is. +func (v QueryValue) hasNamedArg() bool { + if v.Struct == nil { + return !v.HasSqlcSlices() + } + for _, f := range v.Struct.Fields { + if !f.HasSqlcSlice() { + return true + } + } + return false +} + func (v QueryValue) Scan() string { var out []string if v.Struct == nil { diff --git a/internal/codegen/golang/result.go b/internal/codegen/golang/result.go index 82059c54b7..d2f56b7736 100644 --- a/internal/codegen/golang/result.go +++ b/internal/codegen/golang/result.go @@ -5,6 +5,8 @@ import ( "fmt" "sort" "strings" + "unicode" + "unicode/utf8" "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" "github.com/sqlc-dev/sqlc/internal/codegen/sdk" @@ -164,6 +166,26 @@ func columnName(c *plugin.Column, pos int) string { return fmt.Sprintf("column_%d", pos+1) } +// goIdent makes a column name a Go identifier for the variable a single +// column is scanned into: a database may name a column anything, as SQL +// Server names a FOR JSON result JSON_F52E2B61-18A1-11d1-B105-00805F49916B +// and a pivoted one 2023. +func goIdent(name string) string { + name = strings.Map(func(r rune) rune { + if r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) { + return r + } + return '_' + }, name) + if strings.Trim(name, "_") == "" { + return "column_1" + } + if r, _ := utf8.DecodeRuneInString(name); unicode.IsDigit(r) { + name = "_" + name + } + return name +} + func paramName(p *plugin.Parameter) string { if p.Column.Name != "" { return argName(p.Column.Name) @@ -282,8 +304,7 @@ func buildQueries(req *plugin.GenerateRequest, options *opts.Options, enums []En if len(query.Columns) == 1 && query.Columns[0].EmbedTable == nil { c := query.Columns[0] - name := columnName(c, 0) - name = strings.Replace(name, "$", "_", -1) + name := goIdent(columnName(c, 0)) retName := escape(name) // For :one queries the scan destination lives in the same scope as // the query parameters, so reusing a parameter's name would cause diff --git a/internal/codegen/golang/templates/stdlib/queryCode.tmpl b/internal/codegen/golang/templates/stdlib/queryCode.tmpl index 8fd67f1567..827fc8c951 100644 --- a/internal/codegen/golang/templates/stdlib/queryCode.tmpl +++ b/internal/codegen/golang/templates/stdlib/queryCode.tmpl @@ -131,7 +131,20 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} {{- if .Arg.Struct }} {{- $arg := .Arg }} {{- range .Arg.Struct.Fields }} - {{- if .HasSqlcSlice }} + {{- if and .HasSqlcSlice $arg.NamedArgs }} + {{- /* The driver names an unnamed argument @p, its + 1-based position in queryParams. */}} + if len({{$arg.VariableForField .}}) > 0 { + var placeholders []string + for _, v := range {{$arg.VariableForField .}} { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:{{.Column.Name}}*/@{{.Column.Name}}", "NULL") + } + {{- else if .HasSqlcSlice }} if len({{$arg.VariableForField .}}) > 0 { for _, v := range {{$arg.VariableForField .}} { queryParams = append(queryParams, v) @@ -140,6 +153,8 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} } else { query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/?", "NULL", 1) } + {{- else if $arg.NamedArgs }} + queryParams = append(queryParams, {{$arg.NamedArgForField .}}) {{- else }} queryParams = append(queryParams, {{$arg.VariableForField .}}) {{- end }} @@ -149,6 +164,18 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} in a struct), because .Arg.HasSqlcSlices further up above was true, this section is 100% a slice (impossible to get here otherwise). */}} + {{- if .Arg.NamedArgs }} + if len({{.Arg.Name}}) > 0 { + var placeholders []string + for _, v := range {{.Arg.Name}} { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:{{.Arg.Column.Name}}*/@{{.Arg.Column.Name}}", "NULL") + } + {{- else }} if len({{.Arg.Name}}) > 0 { for _, v := range {{.Arg.Name}} { queryParams = append(queryParams, v) @@ -157,6 +184,7 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}} } else { query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/?", "NULL", 1) } + {{- end }} {{- end }} {{- if emitPreparedQueries }} {{ queryRetval . }} {{ queryMethod . }}(ctx, nil, query, queryParams...) diff --git a/internal/compiler/expand.go b/internal/compiler/expand.go index 8c8a490b6d..f8073ae4ff 100644 --- a/internal/compiler/expand.go +++ b/internal/compiler/expand.go @@ -66,6 +66,11 @@ func (c *Compiler) quoteIdent(ident string) string { return c.quote(ident) } } + // A column PIVOT names after a value, as [2023], is no regular + // identifier. + if c.conf.Engine == config.EngineMSSQL && !validPostgresIdent.MatchString(strings.ToLower(ident)) { + return c.quote(ident) + } return ident } @@ -73,6 +78,9 @@ func (c *Compiler) quote(x string) string { switch c.conf.Engine { case config.EngineMySQL: return "`" + x + "`" + case config.EngineMSSQL: + // Brackets quote whatever QUOTED_IDENTIFIER is set to. + return "[" + strings.ReplaceAll(x, "]", "]]") + "]" default: return "\"" + x + "\"" } @@ -100,7 +108,11 @@ func (c *Compiler) starOldFunc(parts []string) func(string) int { } if strings.HasPrefix(s[length:], o) { length += len(o) - } else if quoted := c.quote(o); strings.HasPrefix(s[length:], quoted) { + } else if quoted := c.quote(parts[i]); strings.HasPrefix(s[length:], quoted) { + length += len(quoted) + } else if quoted := `"` + strings.ReplaceAll(parts[i], `"`, `""`) + `"`; strings.HasPrefix(s[length:], quoted) { + // SQL Server quotes with brackets, but reads double quotes + // as an identifier too. length += len(quoted) } else { length += len(o) diff --git a/internal/compiler/parse_core.go b/internal/compiler/parse_core.go index 2e1dfc7042..2ad64cb77b 100644 --- a/internal/compiler/parse_core.go +++ b/internal/compiler/parse_core.go @@ -64,6 +64,7 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess. for _, col := range res.Columns { cols = append(cols, coreColumn(col)) } + cols = embedColumns(raw, cols, res.Stars, pre.Embeds, c.coreCatalog) placeholders, err := placeholderNames(raw) if err != nil { return nil, err @@ -105,6 +106,84 @@ func (c *Compiler) parseQueryCore(raw *ast.RawStmt, src string, pre *preprocess. }, nil } +// embedColumns folds the columns each sqlc.embed() star expanded to into +// the one column codegen embeds the table's struct for. The table is the +// columns' source, so an embed of an alias names the table behind it. The +// struct scans every column of the table in order, so only an expansion +// that is exactly those columns is folded; any other stays flat. +func embedColumns(raw *ast.RawStmt, cols []*Column, stars []core.StarExpansion, embeds preprocess.EmbedSet, cat *core.Catalog) []*Column { + sel, ok := raw.Stmt.(*ast.SelectStmt) + if !ok || len(embeds) == 0 || sel.TargetList == nil { + return cols + } + width := map[int]int{} + for _, star := range stars { + width[star.Location] = len(star.Columns) + } + var out []*Column + i := 0 + for _, item := range sel.TargetList.Items { + res, ok := item.(*ast.ResTarget) + if !ok { + return cols + } + ref, ok := res.Val.(*ast.ColumnRef) + if !ok || !hasStarRef(ref) { + out = append(out, cols[i]) + i++ + continue + } + n, ok := width[res.Location] + if !ok || i+n > len(cols) { + return cols + } + if embed, ok := embeds.Find(ref.Location, res.Location); ok && n > 0 && isWholeTable(cat, cols[i:i+n]) { + out = append(out, &Column{Name: embed.Table.Name, EmbedTable: cols[i].Table}) + } else { + out = append(out, cols[i:i+n]...) + } + i += n + } + return out +} + +// isWholeTable reports whether cols are every column of one table, in the +// table's order, each as nullable as the table's: the optional side of an +// outer join is not, and the table's model could not hold its NULLs. +func isWholeTable(cat *core.Catalog, cols []*Column) bool { + table := cols[0].Table + if table == nil { + return false + } + schema := table.Schema + if schema == "" { + schema = "public" + } + nsOID, err := cat.NamespaceOID(schema) + if err != nil { + return false + } + classOID, err := cat.ClassOID(nsOID, table.Name) + if err != nil { + return false + } + tableCols, err := cat.ClassColumns(classOID) + if err != nil { + return false + } + i := 0 + for _, tc := range tableCols { + if tc.Hidden { + continue + } + if i >= len(cols) || cols[i].Table == nil || *cols[i].Table != *table || cols[i].OriginalName != tc.Name || cols[i].NotNull != tc.NotNull { + return false + } + i++ + } + return i == len(cols) +} + func coreColumn(c core.Column) *Column { col := &Column{ Name: c.Name, diff --git a/internal/core/analyzer/analyzer.go b/internal/core/analyzer/analyzer.go index 2bc94d7338..8b97dc10d1 100644 --- a/internal/core/analyzer/analyzer.go +++ b/internal/core/analyzer/analyzer.go @@ -2,9 +2,11 @@ package analyzer import ( "fmt" + "maps" "github.com/sqlc-dev/sqlc/internal/core" "github.com/sqlc-dev/sqlc/internal/sql/ast" + "github.com/sqlc-dev/sqlc/internal/sql/astutils" ) func Prepare(cat *core.Catalog, stmt ast.Node) (core.PrepareResult, error) { @@ -65,6 +67,10 @@ type analyzer struct { // resolving guards against an alias that refers to itself. resolving map[string]bool + // returning maps the names a RETURNING list may give the statement's + // target to the target's own, while that list is analyzed. + returning map[string]string + // stars are the expansions every star in the statement asked for, shared // with the analyzers of the queries nested in it so one statement reports // all of them. @@ -82,10 +88,16 @@ func (a *analyzer) recordStar(s core.StarExpansion) { // placeholder inside the subquery is reported with the rest, and it sees this // query's scope, so a correlated reference resolves. func (a *analyzer) subquery(s *ast.SelectStmt) (*analyzer, error) { + // A set operation, or a query with no FROM, binds no relations of its + // own, so what is nested in it sees the query it is nested in. + outer := a.scope + if outer == nil || len(outer.rels) == 0 { + outer = a.outer + } sub := &analyzer{ cat: a.cat, params: a.params, - outer: a.scope, + outer: outer, ctes: a.ctes, stars: a.stars, } @@ -277,11 +289,15 @@ func (a *analyzer) analyzeSetOperation(s *ast.SelectStmt) error { if err != nil { return err } - if _, err := a.subquery(s.Rarg); err != nil { + right, err := a.subquery(s.Rarg) + if err != nil { return err } a.columns = left.columns a.scope = left.scope + if rules := a.cat.SetOperations(); rules != nil { + a.columns = a.combineColumns(rules, s.Op, left.columns, right.columns) + } return nil } @@ -291,6 +307,12 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error { if with == nil { return nil } + // The analyzers of nested queries share the map they inherit, so a WITH + // clause binds its names in a copy, out of sight of the enclosing query. + a.ctes = maps.Clone(a.ctes) + if a.ctes == nil { + a.ctes = map[string]scopeRel{} + } for _, item := range listItems(with.Ctes) { cte, ok := item.(*ast.CommonTableExpr) if !ok || cte.Ctename == nil { @@ -300,20 +322,50 @@ func (a *analyzer) bindCTEs(with *ast.WithClause) error { if !ok { continue } + // A recursive CTE refers to itself in the branches after its first, + // which gives the columns, so the first is bound before the rest. + recursive := with.Recursive && sel.Larg != nil && refersTo(sel.Rarg, *cte.Ctename) + if recursive { + anchor := sel + for anchor.Larg != nil { + anchor = anchor.Larg + } + cols, err := a.subqueryColumns(anchor) + if err != nil { + return fmt.Errorf("with %s: %w", *cte.Ctename, err) + } + rel := derivedRel(*cte.Ctename, cols) + renameColumns(&rel, cte.Aliascolnames) + a.ctes[*cte.Ctename] = rel + } cols, err := a.subqueryColumns(sel) if err != nil { return fmt.Errorf("with %s: %w", *cte.Ctename, err) } rel := derivedRel(*cte.Ctename, cols) renameColumns(&rel, cte.Aliascolnames) - if a.ctes == nil { - a.ctes = map[string]scopeRel{} + // What a recursive CTE yields is the union of every round of it, so + // no column stands for a single table column and any may be NULL. + if recursive { + for i := range rel.cols { + rel.cols[i].AttOID = 0 + rel.cols[i].NotNull = false + } } a.ctes[*cte.Ctename] = rel } return nil } +// refersTo reports whether a query reads the relation named name. +func refersTo(n ast.Node, name string) bool { + found := astutils.Search(n, func(n ast.Node) bool { + rv, ok := n.(*ast.RangeVar) + return ok && rv.Relname != nil && *rv.Relname == name && (rv.Schemaname == nil || *rv.Schemaname == "") + }) + return len(found.Items) > 0 +} + // bindAliases records the output names the target list assigns, so a later // clause can refer to a result column by name. func (a *analyzer) bindAliases(targets *ast.List) { diff --git a/internal/core/analyzer/dml.go b/internal/core/analyzer/dml.go index 597723cedd..51975dd5b9 100644 --- a/internal/core/analyzer/dml.go +++ b/internal/core/analyzer/dml.go @@ -11,6 +11,9 @@ func (a *analyzer) analyzeInsert(s *ast.InsertStmt) error { if s.Relation == nil { return fmt.Errorf("insert: missing relation") } + if err := a.bindCTEs(s.WithClause); err != nil { + return err + } rel, err := a.bindRangeVar(s.Relation) if err != nil { return err @@ -24,7 +27,7 @@ func (a *analyzer) analyzeInsert(s *ast.InsertStmt) error { if err := a.bindInsertValues(s.SelectStmt, rel, targets); err != nil { return err } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, rel) } func (a *analyzer) analyzeUpdate(s *ast.UpdateStmt) error { @@ -57,7 +60,7 @@ func (a *analyzer) analyzeUpdate(s *ast.UpdateStmt) error { return fmt.Errorf("where: %w", err) } } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, target) } func (a *analyzer) analyzeDelete(s *ast.DeleteStmt) error { @@ -75,7 +78,7 @@ func (a *analyzer) analyzeDelete(s *ast.DeleteStmt) error { return fmt.Errorf("where: %w", err) } } - return a.projectReturning(s.ReturningList) + return a.projectReturning(s.ReturningList, sc.rels[0]) } // relationScope builds the scope a DML statement operates on: the relations it @@ -142,6 +145,23 @@ func (a *analyzer) bindInsertValues(n ast.Node, rel scopeRel, targets []core.Cla // INSERT ... SELECT inserts whatever the query returns. The rows are not // the statement's result, but the query still holds placeholders. if sel.ValuesLists == nil { + // A placeholder selected as it is takes the type of the column it + // is inserted into, as one in VALUES does. A star selects any + // number of columns, so the items after one are not paired. + if sel.Op == ast.None { + for i, item := range listItems(sel.TargetList) { + rt, ok := item.(*ast.ResTarget) + if !ok || i >= len(targets) { + break + } + if cr, ok := rt.Val.(*ast.ColumnRef); ok && isStar(flattenFields(cr.Fields)) { + break + } + if p, ok := rt.Val.(*ast.ParamRef); ok { + a.inferParam(p, columnType(rel, targets[i])) + } + } + } _, err := a.subqueryColumns(sel) return err } @@ -177,7 +197,16 @@ func (a *analyzer) bindValue(rel scopeRel, target *core.ClassColumn, v ast.Node) return err } -func (a *analyzer) projectReturning(l *ast.List) error { +func (a *analyzer) projectReturning(l *ast.List, target scopeRel) error { + // A dialect's names for the target, such as SQL Server's INSERTED and + // DELETED, refer to it within the list. + if aliases := a.cat.ReturningAliases(); len(aliases) > 0 { + a.returning = map[string]string{} + for _, name := range aliases { + a.returning[name] = target.alias + } + defer func() { a.returning = nil }() + } for _, item := range listItems(l) { rt, ok := item.(*ast.ResTarget) if !ok { diff --git a/internal/core/analyzer/expr.go b/internal/core/analyzer/expr.go index 62a69b273d..7ebebe9b25 100644 --- a/internal/core/analyzer/expr.go +++ b/internal/core/analyzer/expr.go @@ -160,6 +160,9 @@ func (a *analyzer) typeColumnRef(c *ast.ColumnRef) (exprType, error) { relation = parts[0] column = parts[1] } + if target, ok := a.returning[relation]; ok { + relation = target + } rel, col, ok, err := a.resolveColumn(relation, column) if err != nil { return exprType{}, err @@ -462,6 +465,13 @@ func (a *analyzer) typeCase(e *ast.CaseExpr) (exprType, error) { continue } // "CASE x WHEN y" compares y against x; "CASE WHEN y" is a predicate. + // A placeholder for x takes the type of what it is compared with. + if pr, ok := e.Arg.(*ast.ParamRef); ok && argT.typeOID == 0 && argT.expr == nil { + if argT, err = a.typeExpr(when.Expr); err != nil { + return exprType{}, err + } + a.inferParam(pr, argT) + } if e.Arg != nil { if err := a.typeOperands(when.Expr, argT); err != nil { return exprType{}, err @@ -481,49 +491,68 @@ func (a *analyzer) typeCase(e *ast.CaseExpr) (exprType, error) { return t, nil } -// typeCoalesce types COALESCE, which is its first typed argument's type and -// is null only when every argument is. +// typeCoalesce types COALESCE, which is null only when every argument is, +// and of the type its arguments combine to, or its first typed argument's +// for SQL Server's ISNULL. func (a *analyzer) typeCoalesce(e *ast.CoalesceExpr) (exprType, error) { - var out exprType - found := false + types := make([]exprType, 0, len(listItems(e.Args))) nullable := true for _, n := range listItems(e.Args) { t, err := a.typeExpr(n) if err != nil { return exprType{}, err } - if !found && (t.typeOID != 0 || t.expr != nil) { - // The result is an expression's, not the column's it came from. - out = exprType{typeOID: t.typeOID, expr: t.expr} - found = true - } + types = append(types, t) nullable = nullable && t.nullable } - out.nullable = nullable - return out, nil + t := a.commonType(types) + if e.FirstArgType { + for _, first := range types { + if first.typeOID != 0 || first.expr != nil { + t = first + break + } + } + } + // A placeholder there is one that may be NULL. + a.inferAlternatives(listItems(e.Args), t, true) + // The result is an expression's, not the column's it came from. + return exprType{typeOID: t.typeOID, expr: t.expr, nullable: nullable}, nil } -// typeFirstOf types a set of alternative results, taking the first one that has -// a type. The result is nullable when any alternative is, or when the caller -// says the set is not exhaustive. +// typeFirstOf types a set of alternative results, as the type they combine +// to, which without a dialect's rules is the first typed one's. The result +// is nullable when any alternative is, or when the caller says the set is +// not exhaustive. func (a *analyzer) typeFirstOf(nodes []ast.Node, nullable bool) (exprType, error) { - var out exprType - found := false + types := make([]exprType, 0, len(nodes)) for _, n := range nodes { t, err := a.typeExpr(n) if err != nil { return exprType{}, err } - if !found && (t.typeOID != 0 || t.expr != nil) { - out = t - found = true - } + types = append(types, t) nullable = nullable || t.nullable } + out := a.commonType(types) + a.inferAlternatives(nodes, out, false) out.nullable = nullable return out, nil } +// inferAlternatives types a placeholder among alternatives as the type the +// others combine to, as GREATEST(1, @n) takes @n as an integer. +func (a *analyzer) inferAlternatives(nodes []ast.Node, t exprType, nullable bool) { + if t.typeOID == 0 && t.expr == nil { + return + } + for _, n := range nodes { + if p, ok := n.(*ast.ParamRef); ok { + a.inferParam(p, exprType{typeOID: t.typeOID, expr: t.expr, nullable: nullable}) + } + } +} + // typeArrayExpr types ARRAY[...], whose type is an array of its elements'. func (a *analyzer) typeArrayExpr(e *ast.A_ArrayExpr) (exprType, error) { elemT, err := a.typeFirstOf(listItems(e.Elements), false) @@ -984,6 +1013,11 @@ func (a *analyzer) returnType(p core.ProcOverload, argTypes []exprType) exprType } if n, ok := argIndex(name); ok { if n < len(argTypes) { + // A placeholder passed there takes the parameter's type, and so + // does the result. + if argTypes[n].typeOID == 0 && argTypes[n].expr == nil && n < len(p.ArgTypes) && !a.isPolymorphicOID(p.ArgTypes[n]) { + return exprType{typeOID: p.ArgTypes[n]} + } return exprType{typeOID: argTypes[n].typeOID, expr: argTypes[n].expr} } return exprType{} diff --git a/internal/core/analyzer/projection.go b/internal/core/analyzer/projection.go index 17fc3cbf47..a4ac3d6be0 100644 --- a/internal/core/analyzer/projection.go +++ b/internal/core/analyzer/projection.go @@ -129,6 +129,9 @@ func (a *analyzer) emitStar(rt *ast.ResTarget, fields []string) { if len(fields) > 1 { relName = fields[0] } + if target, ok := a.returning[relName]; ok { + relName = target + } // The star is reported along with the columns it covers, so the query text // can be rewritten to name them. star := core.StarExpansion{Location: rt.Location, Fields: fields} diff --git a/internal/core/analyzer/scope.go b/internal/core/analyzer/scope.go index 218a8e0b11..b48986d383 100644 --- a/internal/core/analyzer/scope.go +++ b/internal/core/analyzer/scope.go @@ -52,10 +52,25 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { sc.rels = append(sc.rels, rel) return nil case *ast.JoinExpr: + start := len(sc.rels) if err := a.appendFromItem(sc, v.Larg); err != nil { return err } - return a.appendFromItem(sc, v.Rarg) + mid := len(sc.rels) + if err := a.appendFromItem(sc, v.Rarg); err != nil { + return err + } + if a.cat.OuterJoinsNullable() { + switch v.Jointype { + case ast.JoinTypeLeft: + nullableRels(sc.rels[mid:]) + case ast.JoinTypeRight: + nullableRels(sc.rels[start:mid]) + case ast.JoinTypeFull: + nullableRels(sc.rels[start:]) + } + } + return nil case *ast.RangeFunction: rel, err := a.bindRangeFunction(v) if err != nil { @@ -70,6 +85,13 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { } sc.rels = append(sc.rels, rel) return nil + case *ast.RangePivot: + rel, err := a.bindRangePivot(v) + if err != nil { + return err + } + sc.rels = append(sc.rels, rel) + return nil case *ast.List: // Some engines report a comma-separated FROM as a nested list. for _, item := range listItems(v) { @@ -83,6 +105,20 @@ func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error { } } +// nullableRels makes every column of rels nullable, as the optional side of +// an outer join is. The columns are copied: a relation's column list is the +// catalog's own. +func nullableRels(rels []scopeRel) { + for i := range rels { + cols := make([]core.ClassColumn, len(rels[i].cols)) + for j, c := range rels[i].cols { + c.NotNull = false + cols[j] = c + } + rels[i].cols = cols + } +} + // bindRangeFunction binds a function called in FROM. A set-returning function // stands in for a relation of a single column named after it. func (a *analyzer) bindRangeFunction(rf *ast.RangeFunction) (scopeRel, error) { @@ -122,9 +158,55 @@ func (a *analyzer) bindRangeFunction(rf *ast.RangeFunction) (scopeRel, error) { col.TypeOID, col.NotNull = p.ReturnTypeOID, !p.ReturnNullable } rel.cols = []core.ClassColumn{col} + if cols := a.rowColumns(overloads[0]); cols != nil { + rel.cols = cols + } + if rf.Coldeflist != nil { + rel.cols = a.coldefColumns(rf.Coldeflist, col) + } return rel, nil } +// rowColumns are the columns of a function returning rows of +// table(col type, ...), as a SQL Server table-valued function does. +func (a *analyzer) rowColumns(p core.ProcOverload) []core.ClassColumn { + row, err := a.cat.TypeExprOf(p.ReturnTypeOID) + if err != nil || row.Name != "table" || len(row.Args) == 0 { + return nil + } + var cols []core.ClassColumn + for _, arg := range row.Args { + if arg.Label == "" || arg.Type == nil { + return nil + } + t := a.lookupType(arg.Type.WithNullable(false)) + cols = append(cols, core.ClassColumn{Name: arg.Label, TypeOID: t.typeOID, Type: t.expr, NotNull: !arg.Type.Nullable}) + } + return cols +} + +// coldefColumns are the columns a function's column definition list +// declares, for a function returning rows of more than one column. A +// definition with no type is the function's own result. +func (a *analyzer) coldefColumns(defs *ast.List, result core.ClassColumn) []core.ClassColumn { + var cols []core.ClassColumn + for _, item := range listItems(defs) { + def, ok := item.(*ast.ColumnDef) + if !ok { + continue + } + if def.TypeName == nil { + col := result + col.Name = def.Colname + cols = append(cols, col) + continue + } + t := a.lookupType(core.TypeExprOfTypeName(def.TypeName)) + cols = append(cols, core.ClassColumn{Name: def.Colname, TypeOID: t.typeOID, Type: t.expr, NotNull: def.IsNotNull}) + } + return cols +} + func findFuncCall(l *ast.List) *ast.FuncCall { for _, item := range listItems(l) { switch v := item.(type) { @@ -139,6 +221,67 @@ func findFuncCall(l *ast.List) *ast.FuncCall { return nil } +// bindRangePivot binds PIVOT and UNPIVOT. The columns of the source that +// are not rotated pass through, followed by those the rotation makes, typed +// against the source. +func (a *analyzer) bindRangePivot(p *ast.RangePivot) (scopeRel, error) { + src := &scope{} + if err := a.appendFromItem(src, p.Source); err != nil { + return scopeRel{}, err + } + defer a.binding(src)() + rotated := map[string]bool{} + var made []core.ClassColumn + if p.Unpivot { + // The value column has the type the rotated columns share, and is + // nullable when any of them is. + value := core.ClassColumn{Name: p.ValueColumn, NotNull: true} + for i, item := range listItems(p.InList) { + t, err := a.typeExpr(&ast.ColumnRef{Fields: &ast.List{Items: []ast.Node{item}}}) + if err != nil { + return scopeRel{}, err + } + if i == 0 { + value.TypeOID, value.Type = t.typeOID, t.expr + } + value.NotNull = value.NotNull && !t.nullable + rotated[item.(*ast.String).Str] = true + } + name := a.lookupType(core.TypeExprOfTypeName(p.ForType)) + made = []core.ClassColumn{value, {Name: p.ForColumn, TypeOID: name.typeOID, Type: name.expr}} + } else { + // Each value in the list names a column of the aggregate over the + // rows with that value, null when there are none. + t, err := a.typeExpr(p.Aggregate) + if err != nil { + return scopeRel{}, err + } + rotated[p.ForColumn] = true + for _, arg := range listItems(p.Aggregate.Args) { + if cr, ok := arg.(*ast.ColumnRef); ok { + fields := flattenFields(cr.Fields) + rotated[fields[len(fields)-1]] = true + } + } + for _, item := range listItems(p.InList) { + made = append(made, core.ClassColumn{Name: item.(*ast.String).Str, TypeOID: t.typeOID, Type: t.expr}) + } + } + var rel scopeRel + if p.Alias != nil && p.Alias.Aliasname != nil { + rel.alias = *p.Alias.Aliasname + } + for _, r := range src.rels { + for _, c := range r.cols { + if !rotated[c.Name] { + rel.cols = append(rel.cols, c) + } + } + } + rel.cols = append(rel.cols, made...) + return rel, nil +} + // bindRangeSubselect binds a subquery used as a relation in FROM. func (a *analyzer) bindRangeSubselect(rs *ast.RangeSubselect) (scopeRel, error) { sel, ok := rs.Subquery.(*ast.SelectStmt) diff --git a/internal/core/analyzer/setop.go b/internal/core/analyzer/setop.go new file mode 100644 index 0000000000..52b83ee802 --- /dev/null +++ b/internal/core/analyzer/setop.go @@ -0,0 +1,172 @@ +package analyzer + +import ( + "slices" + + "github.com/sqlc-dev/sqlc/internal/core" + "github.com/sqlc-dev/sqlc/internal/sql/ast" +) + +// combineColumns types each column of a set operation from both of its +// branches by the dialect's rules. A column keeps the first branch's name +// and is read from no one table. It may be NULL in a UNION when either +// branch's may, in an INTERSECT when both may, and in an EXCEPT when the +// first branch's may, since every row it returns is one of those. +func (a *analyzer) combineColumns(rules *core.SetOperationRules, op ast.SetOperation, left, right []core.Column) []core.Column { + out := make([]core.Column, len(left)) + for i, l := range left { + if i >= len(right) { + out[i] = l + continue + } + r := right[i] + col := core.Column{Name: l.Name, NotNull: l.NotNull && r.NotNull} + switch op { + case ast.Intersect: + col.NotNull = l.NotNull || r.NotNull + case ast.Except: + col.NotNull = l.NotNull + } + t := a.combineTypes(rules, columnExprType(l), columnExprType(r)) + t.nullable = !col.NotNull + col.TypeOID = t.typeOID + col.DataType, col.IsArray = a.typeNameOf(t) + col.Type = a.typeExprOf(t) + out[i] = col + } + return out +} + +// combineTypes is the type a column takes from two branches: the one of +// higher precedence, varying when either branch varies, with the length or +// precision that holds both. +func (a *analyzer) combineTypes(rules *core.SetOperationRules, l, r exprType) exprType { + lt, rt := a.exprOf(l), a.exprOf(r) + switch { + case lt == nil: + return r + case rt == nil: + return l + } + li, ri := slices.Index(rules.Precedence, lt.Name), slices.Index(rules.Precedence, rt.Name) + if li < 0 || ri < 0 { + return l + } + winner, loser := lt, rt + if ri < li { + winner, loser = rt, lt + } + out := winner.WithNullable(false) + if varying, ok := rules.Varying[out.Name]; ok && slices.Contains(mapValues(rules.Varying), loser.Name) { + out.Name = varying + } + switch { + case out.Name == rules.Decimal && rules.Decimal != "": + combineDecimal(rules, out, loser) + case len(out.Args) == 1 && len(loser.Args) == 1 && a.sameCategory(lt.Name, rt.Name): + out.Args[0] = widerArg(out.Args[0], loser.Args[0]) + } + // A type with no arguments is its family. Looked up as a declaration + // it would take the dialect's defaults, as varchar is varchar(1). + if len(out.Args) == 0 { + if oid, err := a.cat.TypeOID(out.Name); err == nil { + return exprType{typeOID: oid} + } + } + return a.lookupType(out) +} + +// commonType is the type a dialect gives an expression that yields one of +// several values, as CASE, COALESCE and GREATEST do, by the rules it +// combines a set operation's branches by; a dialect without them takes the +// first typed value's. The result is no one column's. +func (a *analyzer) commonType(types []exprType) exprType { + var out exprType + rules := a.cat.SetOperations() + for i, t := range types { + if t.typeOID == 0 && t.expr == nil { + continue + } + switch { + case out.typeOID == 0 && out.expr == nil: + out = t + case rules == nil: + return out + default: + out = a.combineTypes(rules, out, t) + } + if i > 0 { + out.sourceClassOID, out.sourceAttributeOID, out.sourceTableAlias = 0, 0, "" + } + } + return out +} + +func mapValues(m map[string]string) []string { + out := make([]string, 0, len(m)) + for _, v := range m { + out = append(out, v) + } + return out +} + +// widerArg is the larger of two lengths or precisions, MAX above any. +func widerArg(a, b core.TypeArg) core.TypeArg { + switch { + case a.Ident != nil: + return a + case b.Ident != nil: + return b + case a.Int != nil && b.Int != nil && *b.Int > *a.Int: + return b + } + return a +} + +// combineDecimal gives the exact numeric out the precision and scale that +// hold both it and the other branch's type: the larger scale, and the +// larger count of integer digits, with scale giving way past the maximum +// precision. A family with no decimal form leaves out as it is. +func combineDecimal(rules *core.SetOperationRules, out, other *core.TypeExpr) { + p1, s1, ok1 := decimalForm(rules, out) + p2, s2, ok2 := decimalForm(rules, other) + if !ok1 || !ok2 { + return + } + scale := max(s1, s2) + precision := max(p1-s1, p2-s2) + scale + if limit := rules.DecimalMaxPrecision; limit > 0 && precision > limit { + scale = max(scale-(precision-limit), 0) + precision = limit + } + out.Args = []core.TypeArg{{Int: &precision}, {Int: &scale}} +} + +func decimalForm(rules *core.SetOperationRules, t *core.TypeExpr) (int64, int64, bool) { + if t.Name == rules.Decimal && len(t.Args) == 2 && t.Args[0].Int != nil && t.Args[1].Int != nil { + return *t.Args[0].Int, *t.Args[1].Int, true + } + if form, ok := rules.AsDecimal[t.Name]; ok { + return form[0], form[1], true + } + return 0, 0, false +} + +// sameCategory reports whether two types are of one category, so that the +// length of one says something about the other: the 20 of varchar(20) +// widens an nvarchar(10), but not a datetime2(3). +func (a *analyzer) sameCategory(x, y string) bool { + category := func(name string) string { + oid, err := a.cat.TypeOID(name) + if err != nil { + return "" + } + t, err := a.cat.LookupType(a.familyOID(oid)) + if err != nil { + return "" + } + return t.Category + } + cx := category(x) + return cx != "" && cx == category(y) +} diff --git a/internal/core/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/dialect.go b/internal/core/dialect.go index e192c442c9..a96e75992e 100644 --- a/internal/core/dialect.go +++ b/internal/core/dialect.go @@ -2,6 +2,7 @@ package core import ( "context" + "encoding/json" "fmt" "slices" "strings" @@ -77,6 +78,19 @@ const FlagPropagateNullable = "functions.propagate_nullable" // e.id. const FlagQualifyDuplicateColumns = "columns.qualify_duplicates" +// FlagOuterJoinNullable is set for a dialect whose outer joins fill the +// columns of an unmatched side with NULL, as SQL Server's do. ClickHouse's +// fill them with the type's default instead. +const FlagOuterJoinNullable = "joins.outer_nullable" + +// FlagSetOperations holds, as JSON, the SetOperationRules a dialect types +// the columns of a set operation by. +const FlagSetOperations = "set_operations" + +// FlagReturningAliases holds, comma separated, the names a RETURNING list +// may use for the statement's target. +const FlagReturningAliases = "returning.aliases" + // FlagDefaultSchema holds the schema the dialect puts an unqualified object // in, when that is not the catalog's own default: a type in it is reported // without its schema. @@ -196,6 +210,66 @@ func (c *Catalog) QualifiesDuplicateColumns() bool { return v == "true" } +// OuterJoinsNullable reports whether the columns of an outer join's +// optional side are nullable. +func (c *Catalog) OuterJoinsNullable() bool { + if c.dialectOID == 0 { + return false + } + v, _ := c.DialectFlag(c.dialectOID, FlagOuterJoinNullable) + return v == "true" +} + +// SetOperationRules say how a dialect types a column of UNION, INTERSECT or +// EXCEPT from its branches, as SQL Server does by data type precedence. A +// dialect without them types the column from the first branch. +type SetOperationRules struct { + // Precedence lists type families, highest first: the column takes the + // highest of its branches'. + Precedence []string `json:"precedence"` + // Varying maps a fixed-length family to its varying one, which the + // column takes when another branch varies: char and varchar make + // varchar. + Varying map[string]string `json:"varying,omitempty"` + // Decimal names the exact numeric family, whose precision and scale + // cover every branch's, up to DecimalMaxPrecision, which scale gives + // way to. AsDecimal is the precision and scale another family counts + // as. + Decimal string `json:"decimal,omitempty"` + DecimalMaxPrecision int64 `json:"decimal_max_precision,omitempty"` + AsDecimal map[string][2]int64 `json:"as_decimal,omitempty"` +} + +// SetOperations returns the dialect's set operation rules, or nil. +func (c *Catalog) SetOperations() *SetOperationRules { + if c.dialectOID == 0 { + return nil + } + v, _ := c.DialectFlag(c.dialectOID, FlagSetOperations) + if v == "" { + return nil + } + var rules SetOperationRules + if err := json.Unmarshal([]byte(v), &rules); err != nil { + return nil + } + return &rules +} + +// ReturningAliases lists the names a RETURNING list may qualify a column of +// the statement's target with, as SQL Server's OUTPUT clause reads +// INSERTED.id and DELETED.id. +func (c *Catalog) ReturningAliases() []string { + if c.dialectOID == 0 { + return nil + } + v, _ := c.DialectFlag(c.dialectOID, FlagReturningAliases) + if v == "" { + return nil + } + return strings.Split(v, ",") +} + // DefaultNamespaces lists the namespaces a type is reported from without // qualification: the catalog's default, PostgreSQL's system catalog, and // the dialect's own default schema when it names one. diff --git a/internal/core/schema/schema.go b/internal/core/schema/schema.go index e96d8dbe2a..27b7242a3d 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,46 @@ func applyCreateDomain(cat *core.Catalog, stmt *ast.CreateDomainStmt) error { return err } +func hasOption(options *ast.List, name string) bool { + for _, item := range listItems(options) { + if def, ok := item.(*ast.DefElem); ok && def.Defname != nil && *def.Defname == name { + return true + } + } + return false +} + +// functionQuery is the query a function returns the rows of, which a +// converter passes as the "query" option when the function's columns are +// whatever it selects, as a SQL Server inline table-valued function's are. +func functionQuery(stmt *ast.CreateFunctionStmt) ast.Node { + for _, item := range listItems(stmt.Options) { + if def, ok := item.(*ast.DefElem); ok && def.Defname != nil && *def.Defname == "query" { + return def.Arg + } + } + return nil +} + +// queryRow is the row type of a query's results, table(col type, ...). +func queryRow(cat *core.Catalog, query ast.Node) (*core.TypeExpr, error) { + res, err := analyzer.Prepare(cat, query) + if err != nil { + return nil, err + } + row := &core.TypeExpr{Name: "table"} + for _, col := range res.Columns { + t := col.Type + if t == nil { + if t, err = cat.TypeExprOf(col.TypeOID); err != nil { + return nil, err + } + } + row.Args = append(row.Args, core.TypeArg{Label: col.Name, Type: t.WithNullable(!col.NotNull)}) + } + return row, nil +} + // applyCompositeType records a composite type as a type whose arguments are // its fields, labelled by name. func applyCompositeType(cat *core.Catalog, stmt *ast.CompositeTypeStmt) error { @@ -491,7 +629,19 @@ func applyCreateFunction(cat *core.Catalog, stmt *ast.CreateFunctionStmt) error if stmt.Func == nil || stmt.Func.Name == "" || stmt.ReturnType == nil { return nil } - returnOID, err := cat.ResolveType(stmt.ReturnType) + // A Nullable(T) result is a T the function may return NULL for. + ret := core.TypeExprOfTypeName(stmt.ReturnType) + if ret == nil { + return fmt.Errorf("function %q: missing type name", stmt.Func.Name) + } + if query := functionQuery(stmt); query != nil { + row, err := queryRow(cat, query) + if err != nil { + return fmt.Errorf("function %q: %w", stmt.Func.Name, err) + } + ret = row + } + returnOID, err := cat.ResolveTypeExpr(ret.WithNullable(false)) if err != nil { return fmt.Errorf("function %q: %w", stmt.Func.Name, err) } @@ -518,10 +668,11 @@ func applyCreateFunction(cat *core.Catalog, stmt *ast.CreateFunctionStmt) error } } _, err = cat.CreateProc(core.ProcSpec{ - Name: stmt.Func.Name, - ReturnTypeOID: returnOID, - ReturnSet: stmt.ReturnType != nil && stmt.ReturnType.Setof, - Args: args, + Name: stmt.Func.Name, + ReturnTypeOID: returnOID, + ReturnSet: stmt.ReturnType != nil && stmt.ReturnType.Setof, + ReturnNullable: ret.Nullable, + Args: args, }) return err } diff --git a/internal/core/seed/seed.go b/internal/core/seed/seed.go index 064afedae8..a8e53bde57 100644 --- a/internal/core/seed/seed.go +++ b/internal/core/seed/seed.go @@ -84,6 +84,19 @@ type Settings struct { // ClickHouse names the second id of a join e.id. QualifyDuplicateColumns bool `json:"qualify_duplicate_columns,omitempty"` + // OuterJoinNullable makes the columns of an outer join's optional side + // nullable, as SQL Server fills an unmatched row with NULL. + OuterJoinNullable bool `json:"outer_join_nullable,omitempty"` + + // ReturningAliases are the names a RETURNING list may qualify a column + // of the statement's target with, as SQL Server's OUTPUT clause has + // INSERTED and DELETED. + ReturningAliases []string `json:"returning_aliases,omitempty"` + + // SetOperations types a column of a set operation from every branch, + // rather than from the first. + SetOperations *core.SetOperationRules `json:"set_operations,omitempty"` + // Comparison operators are registered as (T, T) -> Bool for every type in // ComparisonCategories. Comparison []string `json:"comparison,omitempty"` @@ -660,6 +673,25 @@ func (b *builder) consts() error { return err } } + if b.settings.OuterJoinNullable { + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagOuterJoinNullable, "true"); err != nil { + return err + } + } + if b.settings.SetOperations != nil { + rules, err := json.Marshal(b.settings.SetOperations) + if err != nil { + return err + } + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagSetOperations, string(rules)); err != nil { + return err + } + } + if len(b.settings.ReturningAliases) > 0 { + if err := b.cat.SetDialectFlag(b.dialectOID, core.FlagReturningAliases, strings.Join(b.settings.ReturningAliases, ",")); err != nil { + return err + } + } // A schema declares types the seed knows nothing about — enums, domains, // arrays, a SQLite column typed whatever the author felt like. Recording // the comparison operators lets the catalog give those types the same ones. diff --git a/internal/core/types.go b/internal/core/types.go index 7c482a1f2b..99c38e2cb3 100644 --- a/internal/core/types.go +++ b/internal/core/types.go @@ -659,7 +659,11 @@ func (c *Catalog) LookupTypeExpr(t *TypeExpr) (TypeLookup, bool) { // The family is known and the instance is not a row. familyOID, _, err := c.internType(&TypeExpr{Name: canonical.Name}, refuse, false) if err != nil { - return TypeLookup{}, false + // The bare name may take default arguments, as SQL Server's + // decimal is decimal(18,0), and so name no row either. + if familyOID, err = c.TypeOID(canonical.Name); err != nil { + return TypeLookup{}, false + } } return TypeLookup{OID: familyOID, FamilyOID: familyOID, Expr: canonical}, true } diff --git a/internal/endtoend/testdata/analyze_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_alternative_params/mssql/exec.json b/internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql b/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql new file mode 100644 index 0000000000..21aae2f85a --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/query.sql @@ -0,0 +1,4 @@ +-- name: Alternatives :many +SELECT GREATEST(1, @n) AS g, LEAST(n, @cap) AS l, COALESCE(@x, name) AS c, + CASE WHEN id > 0 THEN @label ELSE name END AS k, IIF(id > 0, @alt, at) AS i +FROM t; diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql b/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql new file mode 100644 index 0000000000..53c28cb58a --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2(3) NOT NULL, n BIGINT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json b/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json new file mode 100644 index 0000000000..23fa44d170 --- /dev/null +++ b/internal/endtoend/testdata/analyze_alternative_params/mssql/stdout.json @@ -0,0 +1,122 @@ +[ + { + "name": "Alternatives", + "cmd": ":many", + "columns": [ + { + "name": "g", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "l", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "t" + }, + { + "name": "c", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "k", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "i", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "cap", + "type": { + "name": "bigint" + } + } + }, + { + "number": 3, + "column": { + "name": "x", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + } + }, + { + "number": 4, + "column": { + "name": "label", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 50 + } + ] + } + } + }, + { + "number": 5, + "column": { + "name": "alt", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_apply/mssql/exec.json b/internal/endtoend/testdata/analyze_apply/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_apply/mssql/query.sql b/internal/endtoend/testdata/analyze_apply/mssql/query.sql new file mode 100644 index 0000000000..5362c35b24 --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: LatestBook :many +SELECT a.id, a.name, b.title +FROM authors a +CROSS APPLY (SELECT TOP 1 title FROM books WHERE author_id = a.id ORDER BY id DESC) b; + +-- name: TopBooks :many +SELECT a.name, b.title +FROM authors a +OUTER APPLY (SELECT TOP (@n) title FROM books WHERE author_id = a.id ORDER BY id) b +WHERE a.name = @name; diff --git a/internal/endtoend/testdata/analyze_apply/mssql/schema.sql b/internal/endtoend/testdata/analyze_apply/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_apply/mssql/stdout.json b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json new file mode 100644 index 0000000000..927f596197 --- /dev/null +++ b/internal/endtoend/testdata/analyze_apply/mssql/stdout.json @@ -0,0 +1,97 @@ +[ + { + "name": "LatestBook", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [] + }, + { + "name": "TopBooks", + "cmd": ":many", + "columns": [ + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "bigint" + } + } + }, + { + "number": 2, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json b/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql b/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql new file mode 100644 index 0000000000..60bb2bd927 --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/query.sql @@ -0,0 +1,6 @@ +-- name: CreatedIn :many +SELECT id, + created AT TIME ZONE 'UTC' AS created_utc, + GETDATE() AT TIME ZONE 'UTC' AS now_utc +FROM authors +WHERE created AT TIME ZONE @tz > SYSDATETIMEOFFSET(); diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql b/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json b/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json new file mode 100644 index 0000000000..be5e5a7601 --- /dev/null +++ b/internal/endtoend/testdata/analyze_at_time_zone/mssql/stdout.json @@ -0,0 +1,55 @@ +[ + { + "name": "CreatedIn", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "created_utc", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + }, + { + "name": "now_utc", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "tz", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json b/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql b/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql new file mode 100644 index 0000000000..09290a7263 --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: Combined :many +SELECT GREATEST(i, d52) AS greatest_of, + LEAST(d52, i, si) AS least_of, + CHOOSE(@pick, i, d102) AS chosen, + CASE WHEN i > 0 THEN si ELSE d102 END AS case_of, + IIF(i > 0, v20, n10) AS iif_of, + COALESCE(m, d102) AS coalesce_of, + ISNULL(i, d52) AS isnull_int, + ISNULL(n10, c3) AS isnull_text +FROM t; diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql b/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql new file mode 100644 index 0000000000..df06bb301b --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (i INT NOT NULL, d52 DECIMAL(5,2) NOT NULL, d102 DECIMAL(10,2), v20 VARCHAR(20) NOT NULL, n10 NVARCHAR(10), c3 CHAR(3), si SMALLINT NOT NULL, m MONEY); diff --git a/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json b/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json new file mode 100644 index 0000000000..36ac64c6cf --- /dev/null +++ b/internal/endtoend/testdata/analyze_combined_types/mssql/stdout.json @@ -0,0 +1,122 @@ +[ + { + "name": "Combined", + "cmd": ":many", + "columns": [ + { + "name": "greatest_of", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "least_of", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "chosen", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "case_of", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "iif_of", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "coalesce_of", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + }, + { + "name": "isnull_int", + "type": { + "name": "int" + } + }, + { + "name": "isnull_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pick", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/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..e45b519cf7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: GetComputed :one +SELECT total, doubled, doubled_nn, label, full_label, bio_label, cost, c_isnull, 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..ff84b7616d --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/schema.sql @@ -0,0 +1,18 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(200) NULL, + price INT NOT NULL, + total AS (id * 2), + doubled AS (price * 2) PERSISTED, + doubled_nn AS (price * 2) PERSISTED NOT NULL, + label AS (name + N'!'), + full_label AS (CONCAT(name, bio)), + bio_label AS (bio + N'?'), + cost AS (CAST(price AS decimal(10,2))), + c_isnull AS (ISNULL(bio, N'none')), + 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..f84f5ad7eb --- /dev/null +++ b/internal/endtoend/testdata/analyze_computed_columns/mssql/stdout.json @@ -0,0 +1,336 @@ +[ + { + "name": "GetComputed", + "cmd": ":one", + "columns": [ + { + "name": "total", + "type": { + "name": "bigint", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "doubled_nn", + "type": { + "name": "int", + "nullable": true + }, + "table": "authors" + }, + { + "name": "label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "full_label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "authors" + }, + { + "name": "c_isnull", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + }, + { + "name": "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": "full_label", + "type": { + "name": "nvarchar" + }, + "table": "authors" + }, + { + "name": "bio_label", + "type": { + "name": "nvarchar", + "nullable": true + }, + "table": "authors" + }, + { + "name": "cost", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "authors" + }, + { + "name": "c_isnull", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "authors" + }, + { + "name": "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_convert_style/mssql/exec.json b/internal/endtoend/testdata/analyze_convert_style/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql b/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql new file mode 100644 index 0000000000..3e4f34f892 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Styled :many +SELECT CONVERT(nvarchar(30), at, @style) AS styled, CONVERT(varchar(10), at, 23) AS fixed FROM t; diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql b/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql new file mode 100644 index 0000000000..64963bfc13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2 NOT NULL); diff --git a/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json b/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json new file mode 100644 index 0000000000..e8ba8dfda0 --- /dev/null +++ b/internal/endtoend/testdata/analyze_convert_style/mssql/stdout.json @@ -0,0 +1,42 @@ +[ + { + "name": "Styled", + "cmd": ":many", + "columns": [ + { + "name": "styled", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + }, + { + "name": "fixed", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "style", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json b/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql b/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql new file mode 100644 index 0000000000..b2b0e55321 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: CopyFromAuthor :many +WITH a AS (SELECT id FROM authors WHERE name = @name) +INSERT INTO books (id, author_id, title) +OUTPUT INSERTED.id, INSERTED.title +SELECT CAST(@book_id AS INT), a.id, CAST(@title AS NVARCHAR(200)) FROM a; diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql b/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql new file mode 100644 index 0000000000..ceb008432e --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE books (id INT NOT NULL, author_id INT NOT NULL, title NVARCHAR(200) NOT NULL); +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(100) NOT NULL); diff --git a/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json b/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json new file mode 100644 index 0000000000..af61a35a49 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_insert/mssql/stdout.json @@ -0,0 +1,67 @@ +[ + { + "name": "CopyFromAuthor", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "books" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + }, + "table": "books" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + }, + { + "number": 2, + "column": { + "name": "book_id", + "type": { + "name": "int" + } + } + }, + { + "number": 3, + "column": { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json b/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json new file mode 100644 index 0000000000..b102755fb6 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "postgresql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql b/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql new file mode 100644 index 0000000000..148528dcd1 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/query.sql @@ -0,0 +1,6 @@ +-- name: InnerWithDoesNotLeak :one +WITH x AS (SELECT 1 AS n) +SELECT + (SELECT count(*) FROM (WITH authors AS (SELECT 1 AS id) SELECT id FROM authors) s) AS inner_count, + (SELECT name FROM authors LIMIT 1) AS outer_name +FROM x; diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql b/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql new file mode 100644 index 0000000000..b1098ab8ff --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE authors (id int PRIMARY KEY, name text NOT NULL); diff --git a/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json b/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json new file mode 100644 index 0000000000..5794ccc393 --- /dev/null +++ b/internal/endtoend/testdata/analyze_cte_scope/postgresql/stdout.json @@ -0,0 +1,23 @@ +[ + { + "name": "InnerWithDoesNotLeak", + "cmd": ":one", + "columns": [ + { + "name": "inner_count", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "outer_name", + "type": { + "name": "text", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/exec.json b/internal/endtoend/testdata/analyze_datepart/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/query.sql b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql new file mode 100644 index 0000000000..f1ae69121d --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/query.sql @@ -0,0 +1,13 @@ +-- name: Recent :many +SELECT id, + DATEADD(day, 1, created) AS due, + DATEDIFF(minute, created, SYSUTCDATETIME()) AS age, + DATEPART(month, created) AS month_of, + DATENAME(weekday, created) AS weekday_of +FROM authors +WHERE created > DATEADD(day, @days, SYSUTCDATETIME()); + +-- name: FromStrings :one +SELECT DATEADD(day, 1, '2026-01-01') AS next_day, + DATEADD(day, 1, N'2026-01-01') AS next_day_n, + DATETRUNC(month, '2026-01-15') AS month_start; diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql b/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json new file mode 100644 index 0000000000..6e1436e784 --- /dev/null +++ b/internal/endtoend/testdata/analyze_datepart/mssql/stdout.json @@ -0,0 +1,97 @@ +[ + { + "name": "Recent", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "due", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + }, + { + "name": "age", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "month_of", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "weekday_of", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "days", + "type": { + "name": "int" + } + } + } + ] + }, + { + "name": "FromStrings", + "cmd": ":one", + "columns": [ + { + "name": "next_day", + "type": { + "name": "datetime", + "nullable": true + } + }, + { + "name": "next_day_n", + "type": { + "name": "datetime", + "nullable": true + } + }, + { + "name": "month_start", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/exec.json b/internal/endtoend/testdata/analyze_for_json/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/query.sql b/internal/endtoend/testdata/analyze_for_json/mssql/query.sql new file mode 100644 index 0000000000..e1cb5c0698 --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/query.sql @@ -0,0 +1,13 @@ +-- name: AuthorsJSON :many +SELECT id, name FROM authors WHERE id > @min_id FOR JSON PATH; + +-- name: AuthorsXML :many +SELECT id, name FROM authors FOR XML RAW; + +-- name: AuthorsWithBooks :many +SELECT a.id, + (SELECT b.id, b.title FROM books b WHERE b.author_id = a.id FOR JSON PATH) AS books, + (SELECT b.title + N',' FROM books b WHERE b.author_id = a.id FOR XML PATH('')) AS titles, + (SELECT b.id, b.title FROM books b WHERE b.author_id = a.id FOR XML PATH, TYPE) AS books_xml +FROM authors a +WHERE a.name = @name; diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql b/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json b/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json new file mode 100644 index 0000000000..ec333cc25c --- /dev/null +++ b/internal/endtoend/testdata/analyze_for_json/mssql/stdout.json @@ -0,0 +1,107 @@ +[ + { + "name": "AuthorsJSON", + "cmd": ":many", + "columns": [ + { + "name": "json_f52e2b61-18a1-11d1-b105-00805f49916b", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min_id", + "type": { + "name": "bigint" + }, + "table": "authors" + } + } + ] + }, + { + "name": "AuthorsXML", + "cmd": ":many", + "columns": [ + { + "name": "xml_f52e2b61-18a1-11d1-b105-00805f49916b", + "type": { + "name": "ntext", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "AuthorsWithBooks", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "books", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "titles", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "books_xml", + "type": { + "name": "xml", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json b/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql b/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql new file mode 100644 index 0000000000..d4f08649f4 --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/query.sql @@ -0,0 +1,13 @@ +-- name: SessionInfo :one +SELECT @@ROWCOUNT AS row_count, + @@IDENTITY AS last_identity, + @@SPID AS session_id, + @@VERSION AS version, + @@TRANCOUNT AS tran_count, + @@ERROR AS error, + @@SERVERNAME AS server_name, + @@DATEFIRST AS date_first, + @@DBTS AS dbts; + +-- name: TouchInTransaction :exec +UPDATE readings SET note = @note WHERE id = @id AND @@TRANCOUNT > 0; diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql b/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json b/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json new file mode 100644 index 0000000000..3c1996768c --- /dev/null +++ b/internal/endtoend/testdata/analyze_global_variables/mssql/stdout.json @@ -0,0 +1,123 @@ +[ + { + "name": "SessionInfo", + "cmd": ":one", + "columns": [ + { + "name": "row_count", + "type": { + "name": "int" + } + }, + { + "name": "last_identity", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 38 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "session_id", + "type": { + "name": "smallint" + } + }, + { + "name": "version", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 300 + } + ] + } + }, + { + "name": "tran_count", + "type": { + "name": "int" + } + }, + { + "name": "error", + "type": { + "name": "int" + } + }, + { + "name": "server_name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "date_first", + "type": { + "name": "tinyint", + "nullable": true + } + }, + { + "name": "dbts", + "type": { + "name": "varbinary", + "args": [ + { + "int": 8 + } + ] + } + } + ], + "params": [] + }, + { + "name": "TouchInTransaction", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "note", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + }, + "table": "readings" + } + }, + { + "number": 2, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + } + } + ] + } +] diff --git a/internal/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_insert_select_params/mssql/exec.json b/internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql new file mode 100644 index 0000000000..402d9d8f61 --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: InsertSelected :exec +INSERT INTO t (id, name, at, n) SELECT @a, @b, @c, @d; + +-- name: CopyRow :exec +INSERT INTO t (id, name, at, n) SELECT @a, name, at, n + @inc FROM t WHERE id = @src; + +-- name: CopyWithStar :exec +INSERT INTO t (id, name, at, n) SELECT t2.*, @n FROM (SELECT id, name, at FROM t) t2; diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql b/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql new file mode 100644 index 0000000000..53c28cb58a --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2(3) NOT NULL, n BIGINT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json new file mode 100644 index 0000000000..46f15394ca --- /dev/null +++ b/internal/endtoend/testdata/analyze_insert_select_params/mssql/stdout.json @@ -0,0 +1,110 @@ +[ + { + "name": "InsertSelected", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "a", + "type": { + "name": "int" + }, + "table": "t" + } + }, + { + "number": 2, + "column": { + "name": "b", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "t" + } + }, + { + "number": 3, + "column": { + "name": "c", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + }, + "table": "t" + } + }, + { + "number": 4, + "column": { + "name": "d", + "type": { + "name": "bigint" + }, + "table": "t" + } + } + ] + }, + { + "name": "CopyRow", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "a", + "type": { + "name": "int" + }, + "table": "t" + } + }, + { + "number": 2, + "column": { + "name": "inc", + "type": { + "name": "bigint" + }, + "table": "t" + } + }, + { + "number": 3, + "column": { + "name": "src", + "type": { + "name": "int" + }, + "table": "t" + } + } + ] + }, + { + "name": "CopyWithStar", + "cmd": ":exec", + "columns": [], + "params": [ + { + "number": 1, + "column": { + "name": "n" + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/exec.json b/internal/endtoend/testdata/analyze_isnull/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/query.sql b/internal/endtoend/testdata/analyze_isnull/mssql/query.sql new file mode 100644 index 0000000000..561b7bece7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/query.sql @@ -0,0 +1,7 @@ +-- name: Defaults :many +SELECT id, + ISNULL(note, raw) AS note_or_raw, + ISNULL(note, note) AS still_nullable, + ISNULL(amount, 0) AS amount +FROM readings +WHERE ISNULL(note, raw) = @value; diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql b/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json b/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json new file mode 100644 index 0000000000..60250d2562 --- /dev/null +++ b/internal/endtoend/testdata/analyze_isnull/mssql/stdout.json @@ -0,0 +1,68 @@ +[ + { + "name": "Defaults", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "note_or_raw", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "still_nullable", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "value", + "type": { + "name": "varchar", + "args": [ + { + "int": 10 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json b/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql new file mode 100644 index 0000000000..9eb8705b85 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Trimmed :many +SELECT LEFT(a, 3) AS lf, RIGHT(c, @n) AS rt, TRIM(N'x' FROM a) AS tr, TRIM(LEADING 'x' FROM c) AS tl FROM p; + +-- name: Repeated :many +SELECT REPLICATE(a, @r) AS r, CHARINDEX(N'x', a, @ci) AS ci FROM p; diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql b/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json new file mode 100644 index 0000000000..4743bd3f92 --- /dev/null +++ b/internal/endtoend/testdata/analyze_left_right_trim/mssql/stdout.json @@ -0,0 +1,95 @@ +[ + { + "name": "Trimmed", + "cmd": ":many", + "columns": [ + { + "name": "lf", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "rt", + "type": { + "name": "varchar", + "nullable": true + } + }, + { + "name": "tr", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "tl", + "type": { + "name": "varchar", + "args": [ + { + "int": 5 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + } + ] + }, + { + "name": "Repeated", + "cmd": ":many", + "columns": [ + { + "name": "r", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "ci", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "r", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "ci", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql new file mode 100644 index 0000000000..f9db529a01 --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/query.sql @@ -0,0 +1,22 @@ +-- name: Grouping :many +SELECT g, GROUPING(g) AS gr, GROUPING_ID(g, id) AS gid, APPROX_COUNT_DISTINCT(id) AS approx, CHECKSUM_AGG(id) AS ca +FROM s GROUP BY ROLLUP(g, id); + +-- name: Percentiles :many +SELECT PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY v) OVER (PARTITION BY g) AS med FROM s; + +-- name: Metadata :one +SELECT DB_NAME() AS d, SCHEMA_NAME() AS sn, OBJECT_ID(N'dbo.s') AS o, OBJECT_NAME(@oid) AS obj, + IDENT_CURRENT(N's') AS ic, ROWCOUNT_BIG() AS rc, ORIGINAL_LOGIN() AS ol, DB_ID() AS dbid, + ERROR_MESSAGE() AS em, ERROR_NUMBER() AS en, XACT_STATE() AS xs, SESSION_CONTEXT(N'k') AS sc; + +-- name: Strings :many +SELECT STRING_ESCAPE(g, 'json') AS se, SOUNDEX(g) AS sx, DIFFERENCE(g, @other) AS df, + LTRIM(g, N'x') AS lt, RTRIM(g, N'x') AS rt, COMPRESS(g) AS c, REGEXP_REPLACE(g, @pattern, N'b') AS rr, + REGEXP_SUBSTR(g, N'a') AS rs, REGEXP_COUNT(g, N'a') AS rc +FROM s; + +-- name: Bits :many +SELECT BIT_COUNT(id) AS bc, LEFT_SHIFT(id, 1) AS ls, GET_BIT(id, 1) AS gb, SET_BIT(id, @bit) AS sb, + DATE_BUCKET(week, 2, CAST(SYSDATETIME() AS date)) AS db +FROM s; diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql new file mode 100644 index 0000000000..dc9cce113a --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE s (id INT NOT NULL, g NVARCHAR(10) NOT NULL, v DECIMAL(10,2) NOT NULL, f FLOAT NULL); diff --git a/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json new file mode 100644 index 0000000000..ff93fb5e24 --- /dev/null +++ b/internal/endtoend/testdata/analyze_more_functions/mssql/stdout.json @@ -0,0 +1,367 @@ +[ + { + "name": "Grouping", + "cmd": ":many", + "columns": [ + { + "name": "g", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + }, + "table": "s" + }, + { + "name": "gr", + "type": { + "name": "tinyint" + } + }, + { + "name": "gid", + "type": { + "name": "int" + } + }, + { + "name": "approx", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "ca", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Percentiles", + "cmd": ":many", + "columns": [ + { + "name": "med", + "type": { + "name": "float", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Metadata", + "cmd": ":one", + "columns": [ + { + "name": "d", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "sn", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "o", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "obj", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "ic", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 38 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "rc", + "type": { + "name": "bigint" + } + }, + { + "name": "ol", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "dbid", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "em", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "en", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "xs", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "sc", + "type": { + "name": "sql_variant", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "oid", + "type": { + "name": "int" + } + } + } + ] + }, + { + "name": "Strings", + "cmd": ":many", + "columns": [ + { + "name": "se", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "sx", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "df", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "lt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "rt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "c", + "type": { + "name": "varbinary", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "rr", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "rs", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + }, + { + "name": "rc", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "other", + "type": { + "name": "varchar" + } + } + }, + { + "number": 2, + "column": { + "name": "pattern" + } + } + ] + }, + { + "name": "Bits", + "cmd": ":many", + "columns": [ + { + "name": "bc", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "ls", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "gb", + "type": { + "name": "bit", + "nullable": true + } + }, + { + "name": "sb", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "db", + "type": { + "name": "date", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "bit", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql new file mode 100644 index 0000000000..da4ff4cc83 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/query.sql @@ -0,0 +1,23 @@ +-- name: Numeric :many +SELECT + royalties * 2 AS doubled, + royalties / units AS per_unit, + units * weight AS weighted, + ratio + units AS ratio_units, + ratio * weight AS ratio_weight, + units + total AS units_total, + refunds - flags AS net_refunds, + fee * units AS fee_units, + small_fee + units AS small_fee_units, + small_fee + fee AS fees, + units % refunds AS remainder +FROM sales; + +-- name: Concatenation :many +SELECT + code + code AS codes, + code + title AS code_title, + ncode + title AS ncode_title, + title + name AS title_name, + code + ncode AS code_ncode +FROM sales; diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql new file mode 100644 index 0000000000..891366facd --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/schema.sql @@ -0,0 +1,16 @@ +CREATE TABLE sales ( + id INT IDENTITY(1,1) PRIMARY KEY, + royalties DECIMAL(10,2), + units INT, + refunds SMALLINT, + flags TINYINT, + total BIGINT, + ratio REAL, + weight FLOAT, + fee MONEY, + small_fee SMALLMONEY, + code CHAR(4), + title VARCHAR(50), + ncode NCHAR(4), + name NVARCHAR(50) +); diff --git a/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json new file mode 100644 index 0000000000..7ed41e25d7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_arithmetic/mssql/stdout.json @@ -0,0 +1,128 @@ +[ + { + "name": "Numeric", + "cmd": ":many", + "columns": [ + { + "name": "doubled", + "type": { + "name": "decimal", + "nullable": true + } + }, + { + "name": "per_unit", + "type": { + "name": "decimal", + "nullable": true + } + }, + { + "name": "weighted", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "ratio_units", + "type": { + "name": "real", + "nullable": true + } + }, + { + "name": "ratio_weight", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "units_total", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "net_refunds", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "fee_units", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "small_fee_units", + "type": { + "name": "smallmoney", + "nullable": true + } + }, + { + "name": "fees", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "remainder", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Concatenation", + "cmd": ":many", + "columns": [ + { + "name": "codes", + "type": { + "name": "char", + "nullable": true + } + }, + { + "name": "code_title", + "type": { + "name": "varchar", + "nullable": true + } + }, + { + "name": "ncode_title", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "title_name", + "type": { + "name": "nvarchar", + "nullable": true + } + }, + { + "name": "code_ncode", + "type": { + "name": "nchar", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql new file mode 100644 index 0000000000..e8468281a8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/query.sql @@ -0,0 +1,71 @@ +-- name: Ranking :many +SELECT + id, + LAG(price) OVER (ORDER BY id) AS previous_price, + LEAD(title, 1, 'none') OVER (ORDER BY id) AS next_title, + FIRST_VALUE(subtitle) OVER (ORDER BY id) AS first_subtitle, + LAST_VALUE(qty) OVER (ORDER BY id) AS last_qty +FROM books; + +-- name: Nulls :many +SELECT + ISNULL(rating, 0) AS rating, + ISNULL(discount, 0) AS discount, + NULLIF(qty, 0) AS qty, + CHOOSE(1, title, subtitle) AS chosen, + GREATEST(price, discount) AS greatest_price, + LEAST(title, subtitle) AS least_title +FROM books; + +-- name: Strings :many +SELECT + REPLACE(title, 'a', 'b') AS replaced, + REPLACE(note, 'a', 'b') AS replaced_n, + REVERSE(title) AS reversed, + CHARINDEX('a', title) AS position, + PATINDEX('%a%', note) AS pattern_position, + FORMAT(price, 'N2') AS formatted, + QUOTENAME(name) AS quoted, + STR(weight, 10, 2) AS str_weight +FROM books; + +-- name: Aggregates :one +SELECT + STRING_AGG(title, ',') AS titles, + STRING_AGG(note, ',') AS notes, + STDEV(qty) AS qty_stdev +FROM books; + +-- name: Math :many +SELECT + ABS(qty) AS abs_qty, + ABS(price) AS abs_price, + ABS(cost) AS abs_cost, + CEILING(weight) AS ceiling_weight, + FLOOR(rating) AS floor_rating, + ROUND(discount, 1) AS rounded, + POWER(weight, 2) AS squared, + SQRT(qty) AS root, + SIGN(discount) AS sign_discount +FROM books; + +-- name: Dates :many +SELECT + YEAR(published) AS year, + MONTH(updated) AS month, + DAY(published) AS day, + EOMONTH(published) AS month_end, + DATEFROMPARTS(rating, 1, 1) AS start_date, + DATETIME2FROMPARTS(rating, 1, 1, 0, 0, 0, 0, 3) AS start_time, + SWITCHOFFSET(offset_at, '+01:00') AS switched +FROM books; + +-- name: Json :many +SELECT + ISJSON(doc) AS is_json, + JSON_VALUE(doc, '$.a') AS json_value, + JSON_QUERY(doc, '$.a') AS json_query, + JSON_MODIFY(doc, '$.a', 1) AS json_modified, + HASHBYTES('SHA2_256', title) AS hash, + CHECKSUM(title) AS checksum +FROM books; diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql new file mode 100644 index 0000000000..c41fbe240e --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/schema.sql @@ -0,0 +1,17 @@ +CREATE TABLE books ( + id INT IDENTITY(1,1) PRIMARY KEY, + title VARCHAR(100) NOT NULL, + subtitle VARCHAR(100), + name NVARCHAR(100) NOT NULL, + note NVARCHAR(200), + price DECIMAL(10,2) NOT NULL, + discount DECIMAL(5,2), + qty INT NOT NULL, + rating INT, + weight FLOAT, + cost MONEY, + published DATE, + updated DATETIME2(3), + offset_at DATETIMEOFFSET, + doc NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json new file mode 100644 index 0000000000..3983024aad --- /dev/null +++ b/internal/endtoend/testdata/analyze_mssql_functions/mssql/stdout.json @@ -0,0 +1,495 @@ +[ + { + "name": "Ranking", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "books" + }, + { + "name": "previous_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "next_title", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "first_subtitle", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "last_qty", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Nulls", + "cmd": ":many", + "columns": [ + { + "name": "rating", + "type": { + "name": "int" + } + }, + { + "name": "discount", + "type": { + "name": "decimal", + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "chosen", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "greatest_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "least_title", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Strings", + "cmd": ":many", + "columns": [ + { + "name": "replaced", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "replaced_n", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "reversed", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "position", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "pattern_position", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "formatted", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "quoted", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 258 + } + ] + } + }, + { + "name": "str_weight", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Aggregates", + "cmd": ":one", + "columns": [ + { + "name": "titles", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "notes", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "qty_stdev", + "type": { + "name": "float", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "Math", + "cmd": ":many", + "columns": [ + { + "name": "abs_qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "abs_price", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "abs_cost", + "type": { + "name": "money", + "nullable": true + } + }, + { + "name": "ceiling_weight", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "floor_rating", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "rounded", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "squared", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "root", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "sign_discount", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Dates", + "cmd": ":many", + "columns": [ + { + "name": "year", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "month", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "day", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "month_end", + "type": { + "name": "date", + "nullable": true + } + }, + { + "name": "start_date", + "type": { + "name": "date", + "nullable": true + } + }, + { + "name": "start_time", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 3 + } + ] + } + }, + { + "name": "switched", + "type": { + "name": "datetimeoffset", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Json", + "cmd": ":many", + "columns": [ + { + "name": "is_json", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "json_value", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "json_query", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "json_modified", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "hash", + "type": { + "name": "varbinary", + "nullable": true, + "args": [ + { + "int": 8000 + } + ] + } + }, + { + "name": "checksum", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json b/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql b/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql new file mode 100644 index 0000000000..6c70713f9e --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Literals :many +SELECT N'hello' AS a1, N'' AS a2, 'hi' AS a3, a + N'xy' AS a4, COALESCE(NULLIF(a, N''), N'none') AS a5 FROM p WHERE a LIKE N'%x%' AND b = @b; diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql b/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json b/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json new file mode 100644 index 0000000000..2e689dcf2f --- /dev/null +++ b/internal/endtoend/testdata/analyze_national_literals/mssql/stdout.json @@ -0,0 +1,70 @@ +[ + { + "name": "Literals", + "cmd": ":many", + "columns": [ + { + "name": "a1", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "a2", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 1 + } + ] + } + }, + { + "name": "a3", + "type": { + "name": "varchar" + } + }, + { + "name": "a4", + "type": { + "name": "nvarchar" + } + }, + { + "name": "a5", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 10 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "b", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 20 + } + ] + }, + "table": "p" + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json b/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql b/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql new file mode 100644 index 0000000000..886b0e0ab1 --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Literals :many +SELECT 1.5 AS a, 0.5 AS b, 10.00 AS c, 007.10 AS d, 2147483647 AS e, 2147483648 AS f, 12345678901 AS g, -1.5 AS h, 1e5 AS i, 0 - 1.5 AS j FROM p; diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql b/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql new file mode 100644 index 0000000000..2008fa5e89 --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p (a NVARCHAR(10) NOT NULL, b NVARCHAR(20) NOT NULL, c VARCHAR(5) NOT NULL, d DECIMAL(10,2) NOT NULL, e DECIMAL(5,3) NOT NULL, i INT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json b/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json new file mode 100644 index 0000000000..33e44239aa --- /dev/null +++ b/internal/endtoend/testdata/analyze_numeric_literals/mssql/stdout.json @@ -0,0 +1,117 @@ +[ + { + "name": "Literals", + "cmd": ":many", + "columns": [ + { + "name": "a", + "type": { + "name": "decimal", + "args": [ + { + "int": 2 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "b", + "type": { + "name": "decimal", + "args": [ + { + "int": 1 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "c", + "type": { + "name": "decimal", + "args": [ + { + "int": 4 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "d", + "type": { + "name": "decimal", + "args": [ + { + "int": 3 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "e", + "type": { + "name": "int" + } + }, + { + "name": "f", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "g", + "type": { + "name": "decimal", + "args": [ + { + "int": 11 + }, + { + "int": 0 + } + ] + } + }, + { + "name": "h", + "type": { + "name": "decimal" + } + }, + { + "name": "i", + "type": { + "name": "float" + } + }, + { + "name": "j", + "type": { + "name": "decimal" + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_paging/mssql/exec.json b/internal/endtoend/testdata/analyze_paging/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_paging/mssql/query.sql b/internal/endtoend/testdata/analyze_paging/mssql/query.sql new file mode 100644 index 0000000000..9caa757d82 --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: TopAuthors :many +SELECT TOP (@n) id, name FROM authors ORDER BY id; + +-- name: PageAuthors :many +SELECT id, name FROM authors ORDER BY id OFFSET @skip ROWS FETCH NEXT @take ROWS ONLY; + +-- name: TopPercent :many +SELECT TOP (@pct) PERCENT id, name FROM authors ORDER BY id; diff --git a/internal/endtoend/testdata/analyze_paging/mssql/schema.sql b/internal/endtoend/testdata/analyze_paging/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_paging/mssql/stdout.json b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json new file mode 100644 index 0000000000..6c3921721d --- /dev/null +++ b/internal/endtoend/testdata/analyze_paging/mssql/stdout.json @@ -0,0 +1,119 @@ +[ + { + "name": "TopAuthors", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "bigint" + } + } + } + ] + }, + { + "name": "PageAuthors", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "skip", + "type": { + "name": "bigint" + } + } + }, + { + "number": 2, + "column": { + "name": "take", + "type": { + "name": "bigint" + } + } + } + ] + }, + { + "name": "TopPercent", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pct", + "type": { + "name": "float" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/exec.json b/internal/endtoend/testdata/analyze_pivot/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/query.sql b/internal/endtoend/testdata/analyze_pivot/mssql/query.sql new file mode 100644 index 0000000000..1ab8ee5bc5 --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/query.sql @@ -0,0 +1,17 @@ +-- name: PivotDerived :many +SELECT pv.* FROM (SELECT author_id, year, amount FROM sales WHERE author_id > @min_author) s +PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; + +-- name: PivotTable :many +SELECT * FROM sales PIVOT (COUNT(amount) FOR year IN ([2023], [2024])) AS pv; + +-- name: PivotColumns :many +SELECT pv.author_id, pv.[2023] FROM sales PIVOT (MAX(amount) FOR year IN ([2023])) pv +WHERE pv.id = @id; + +-- name: Unpivot :many +SELECT u.id, u.metric, u.value FROM stats s +UNPIVOT (value FOR metric IN (q1, q2, q3)) u; + +-- name: UnpivotStar :many +SELECT * FROM stats UNPIVOT (value FOR metric IN (q1)) AS u; diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql b/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql new file mode 100644 index 0000000000..a32279545a --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/schema.sql @@ -0,0 +1,15 @@ +CREATE TABLE sales ( + id INT NOT NULL PRIMARY KEY, + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL, + note NVARCHAR(50) NULL +); + +CREATE TABLE stats ( + id INT NOT NULL PRIMARY KEY, + name VARCHAR(20) NULL, + q1 INT NOT NULL, + q2 INT NULL, + q3 INT NULL +); diff --git a/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json b/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json new file mode 100644 index 0000000000..9c91bb88c8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_pivot/mssql/stdout.json @@ -0,0 +1,215 @@ +[ + { + "name": "PivotDerived", + "cmd": ":many", + "columns": [ + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "2024", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min_author", + "type": { + "name": "int" + }, + "table": "sales" + } + } + ] + }, + { + "name": "PivotTable", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "note", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "2024", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "PivotColumns", + "cmd": ":many", + "columns": [ + { + "name": "author_id", + "type": { + "name": "int" + }, + "table": "sales" + }, + { + "name": "2023", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "sales" + } + } + ] + }, + { + "name": "Unpivot", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "stats" + }, + { + "name": "metric", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + }, + { + "name": "value", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [] + }, + { + "name": "UnpivotStar", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "stats" + }, + { + "name": "name", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + }, + "table": "stats" + }, + { + "name": "q2", + "type": { + "name": "int", + "nullable": true + }, + "table": "stats" + }, + { + "name": "q3", + "type": { + "name": "int", + "nullable": true + }, + "table": "stats" + }, + { + "name": "value", + "type": { + "name": "int" + } + }, + { + "name": "metric", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 128 + } + ] + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json b/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql b/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql new file mode 100644 index 0000000000..bf18662350 --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/query.sql @@ -0,0 +1,18 @@ +-- name: Subtree :many +WITH tree AS ( + SELECT id, parent_id, name, 0 AS depth FROM nodes WHERE id = @root + UNION ALL + SELECT n.id, n.parent_id, n.name, t.depth + 1 + FROM nodes n + JOIN tree t ON n.parent_id = t.id +) +SELECT id, parent_id, name, depth FROM tree +OPTION (MAXRECURSION 100); + +-- name: Numbers :many +WITH seq(i) AS ( + SELECT 1 + UNION ALL + SELECT i + 1 FROM seq WHERE i < @max +) +SELECT i FROM seq; diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql b/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql new file mode 100644 index 0000000000..89c256a5ef --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE nodes ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + parent_id BIGINT, + name NVARCHAR(100) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json b/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json new file mode 100644 index 0000000000..f864eb2874 --- /dev/null +++ b/internal/endtoend/testdata/analyze_recursive_cte/mssql/stdout.json @@ -0,0 +1,77 @@ +[ + { + "name": "Subtree", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "parent_id", + "type": { + "name": "bigint", + "nullable": true + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "depth", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "root", + "type": { + "name": "bigint" + }, + "table": "nodes" + } + } + ] + }, + { + "name": "Numbers", + "cmd": ":many", + "columns": [ + { + "name": "i", + "type": { + "name": "int", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "max", + "type": { + "name": "int" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_round/mssql/exec.json b/internal/endtoend/testdata/analyze_round/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_round/mssql/query.sql b/internal/endtoend/testdata/analyze_round/mssql/query.sql new file mode 100644 index 0000000000..9c348e718f --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/query.sql @@ -0,0 +1,7 @@ +-- name: Rounded :many +SELECT ROUND(price, 1) AS rounded, + ROUND(price, 1, 1) AS truncated, + ROUND(ratio, 2, 1) AS ratio_truncated, + ROUND(qty, -1, 1) AS qty_truncated, + ROUND(fee, 2, 1) AS fee_truncated +FROM prices; diff --git a/internal/endtoend/testdata/analyze_round/mssql/schema.sql b/internal/endtoend/testdata/analyze_round/mssql/schema.sql new file mode 100644 index 0000000000..f759dbea38 --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE prices ( + price DECIMAL(10,2), + ratio FLOAT, + qty INT, + fee MONEY +); diff --git a/internal/endtoend/testdata/analyze_round/mssql/stdout.json b/internal/endtoend/testdata/analyze_round/mssql/stdout.json new file mode 100644 index 0000000000..871c0961ce --- /dev/null +++ b/internal/endtoend/testdata/analyze_round/mssql/stdout.json @@ -0,0 +1,60 @@ +[ + { + "name": "Rounded", + "cmd": ":many", + "columns": [ + { + "name": "rounded", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "truncated", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "ratio_truncated", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "qty_truncated", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "fee_truncated", + "type": { + "name": "money", + "nullable": true + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql new file mode 100644 index 0000000000..89bb6eef73 --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: ItemTotals :many +SELECT id, dbo.f_add(id, price) AS total, dbo.f_add(@n, DEFAULT) AS d, dbo.label(@s) AS l FROM items; diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql new file mode 100644 index 0000000000..bbb242872d --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/schema.sql @@ -0,0 +1,8 @@ +CREATE TABLE items (id INT NOT NULL, price DECIMAL(10,2) NOT NULL); +GO +CREATE FUNCTION dbo.f_add(@a INT, @b DECIMAL(10,2) = 1) RETURNS DECIMAL(12,2) +AS BEGIN RETURN @a + @b END; +GO +CREATE FUNCTION label(@s NVARCHAR(20)) RETURNS NVARCHAR(30) WITH SCHEMABINDING +AS BEGIN RETURN N'x' + @s END; +GO diff --git a/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json new file mode 100644 index 0000000000..9da8e78da8 --- /dev/null +++ b/internal/endtoend/testdata/analyze_scalar_functions/mssql/stdout.json @@ -0,0 +1,82 @@ +[ + { + "name": "ItemTotals", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + }, + { + "name": "total", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "d", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "l", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "s", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 20 + } + ] + } + } + } + ] + } +] diff --git a/internal/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_set_operations/mssql/exec.json b/internal/endtoend/testdata/analyze_set_operations/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql new file mode 100644 index 0000000000..344b803714 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/query.sql @@ -0,0 +1,32 @@ +-- name: Everyone :many +SELECT id, name, code, score, joined FROM people WHERE name <> @skip +UNION ALL +SELECT id, title, code, budget, founded FROM orgs; + +-- name: Names :many +SELECT name FROM people +UNION +SELECT nickname FROM people +UNION +SELECT NULL; + +-- name: SharedNicknames :many +SELECT nickname, id FROM people +INTERSECT +SELECT title, id FROM orgs; + +-- name: OnlyPeople :many +SELECT id, score FROM people +EXCEPT +SELECT id, budget FROM orgs; + + +-- name: Amounts :many +SELECT qty AS v FROM ledger +UNION ALL +SELECT amount FROM ledger +UNION ALL +SELECT flag FROM ledger; + +-- name: LiteralUnion :many +SELECT 'active' AS status UNION ALL SELECT 'inactive'; diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql new file mode 100644 index 0000000000..d5863672a6 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/schema.sql @@ -0,0 +1,22 @@ +CREATE TABLE people ( + id INT IDENTITY(1,1) PRIMARY KEY, + name VARCHAR(50) NOT NULL, + nickname NVARCHAR(20), + code CHAR(3) NOT NULL, + score DECIMAL(10,2) NOT NULL, + joined DATETIME2(3) NOT NULL +); + +CREATE TABLE orgs ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + code VARCHAR(5), + budget MONEY NOT NULL, + founded DATE NOT NULL +); + +CREATE TABLE ledger ( + qty INT NOT NULL, + flag BIT NOT NULL, + amount DECIMAL(5,2) NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json new file mode 100644 index 0000000000..97efa9f313 --- /dev/null +++ b/internal/endtoend/testdata/analyze_set_operations/mssql/stdout.json @@ -0,0 +1,183 @@ +[ + { + "name": "Everyone", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "code", + "type": { + "name": "varchar", + "nullable": true, + "args": [ + { + "int": 5 + } + ] + } + }, + { + "name": "score", + "type": { + "name": "decimal", + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + }, + { + "name": "joined", + "type": { + "name": "datetime2", + "args": [ + { + "int": 3 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "skip", + "type": { + "name": "varchar", + "args": [ + { + "int": 50 + } + ] + }, + "table": "people" + } + } + ] + }, + { + "name": "Names", + "cmd": ":many", + "columns": [ + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + } + ], + "params": [] + }, + { + "name": "SharedNicknames", + "cmd": ":many", + "columns": [ + { + "name": "nickname", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "id", + "type": { + "name": "bigint" + } + } + ], + "params": [] + }, + { + "name": "OnlyPeople", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + } + }, + { + "name": "score", + "type": { + "name": "decimal", + "args": [ + { + "int": 19 + }, + { + "int": 4 + } + ] + } + } + ], + "params": [] + }, + { + "name": "Amounts", + "cmd": ":many", + "columns": [ + { + "name": "v", + "type": { + "name": "decimal", + "args": [ + { + "int": 12 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [] + }, + { + "name": "LiteralUnion", + "cmd": ":many", + "columns": [ + { + "name": "status", + "type": { + "name": "varchar" + } + } + ], + "params": [] + } +] 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_table_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_table_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql new file mode 100644 index 0000000000..677428a56e --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/query.sql @@ -0,0 +1,19 @@ +-- name: Elements :many +SELECT d.id, j.[key], j.value, j.type +FROM documents d +CROSS APPLY OPENJSON(d.body) j +WHERE d.id = @id; + +-- name: Items :many +SELECT d.id, i.name, i.qty, i.extra +FROM documents d +CROSS APPLY OPENJSON(d.body, '$.items') + WITH (name NVARCHAR(50) '$.name', qty INT '$.qty', extra NVARCHAR(MAX) '$.extra' AS JSON) i; + +-- name: Words :many +SELECT d.id, w.value, w.ordinal +FROM documents d +CROSS APPLY STRING_SPLIT(d.title, N' ', 1) w; + +-- name: Series :many +SELECT value FROM GENERATE_SERIES(1, 10); diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql new file mode 100644 index 0000000000..f70422d2a7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE documents ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + body NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json new file mode 100644 index 0000000000..529f8710d7 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_functions/mssql/stdout.json @@ -0,0 +1,145 @@ +[ + { + "name": "Elements", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "key", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "value", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "type", + "type": { + "name": "tinyint" + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + } + } + ] + }, + { + "name": "Items", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 50 + } + ] + } + }, + { + "name": "qty", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "extra", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [] + }, + { + "name": "Words", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "value", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + } + }, + { + "name": "ordinal", + "type": { + "name": "bigint" + } + } + ], + "params": [] + }, + { + "name": "Series", + "cmd": ":many", + "columns": [ + { + "name": "value", + "type": { + "name": "int" + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql new file mode 100644 index 0000000000..703a1aa0a2 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: ApplyBoth :many +SELECT o.id, o.name, o.price, m.id AS mid, m.label FROM dbo.items_over(@p) o CROSS APPLY dbo.ms_items(o.id) m; + +-- name: InlineStar :many +SELECT * FROM items_over(@min); + +-- name: OuterApply :many +SELECT i.id, m.label FROM items i OUTER APPLY ms_items(i.id) m WHERE i.id = @id; diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql new file mode 100644 index 0000000000..9f7b6cba9d --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE items (id INT NOT NULL, name NVARCHAR(20) NULL, price DECIMAL(10,2) NOT NULL); +GO +CREATE FUNCTION dbo.items_over(@min DECIMAL(10,2)) RETURNS TABLE +AS RETURN SELECT id, name, price FROM items WHERE price > @min; +GO +CREATE FUNCTION ms_items(@n INT) RETURNS @t TABLE (id INT NOT NULL, label NVARCHAR(30)) +AS BEGIN + INSERT @t SELECT id, name FROM items WHERE id > @n; + RETURN; +END; +GO diff --git a/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json new file mode 100644 index 0000000000..f8997abd13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_table_valued_functions/mssql/stdout.json @@ -0,0 +1,171 @@ +[ + { + "name": "ApplyBoth", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "price", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "mid", + "type": { + "name": "int" + } + }, + { + "name": "label", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "p", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + } + ] + }, + { + "name": "InlineStar", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + } + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "price", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + } + } + ] + }, + { + "name": "OuterApply", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + }, + { + "name": "label", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 30 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "items" + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json b/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql b/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql new file mode 100644 index 0000000000..7c8561d078 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Sampled :many +SELECT id FROM t TABLESAMPLE (@pct PERCENT) WHERE id > @min; + +-- name: SampledRows :many +SELECT id FROM t TABLESAMPLE SYSTEM (@n ROWS) REPEATABLE (@seed); diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql b/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql new file mode 100644 index 0000000000..64963bfc13 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL, at DATETIME2 NOT NULL); diff --git a/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json b/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json new file mode 100644 index 0000000000..9ea3c11619 --- /dev/null +++ b/internal/endtoend/testdata/analyze_tablesample/mssql/stdout.json @@ -0,0 +1,69 @@ +[ + { + "name": "Sampled", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "t" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "pct", + "type": { + "name": "float" + } + } + }, + { + "number": 2, + "column": { + "name": "min", + "type": { + "name": "int" + }, + "table": "t" + } + } + ] + }, + { + "name": "SampledRows", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "t" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "n", + "type": { + "name": "bigint" + } + } + }, + { + "number": 2, + "column": { + "name": "seed", + "type": { + "name": "bigint" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/exec.json b/internal/endtoend/testdata/analyze_temporal/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/query.sql b/internal/endtoend/testdata/analyze_temporal/mssql/query.sql new file mode 100644 index 0000000000..06320c8b79 --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: PriceAsOf :many +SELECT id, amount FROM prices FOR SYSTEM_TIME AS OF @at WHERE id = @id; + +-- name: PriceHistory :many +SELECT id, amount, valid_from, valid_to FROM prices FOR SYSTEM_TIME BETWEEN @from AND @to; diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql b/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql new file mode 100644 index 0000000000..971a5a65cd --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE prices ( + id INT PRIMARY KEY, + amount DECIMAL(10,2) NOT NULL, + valid_from DATETIME2 GENERATED ALWAYS AS ROW START NOT NULL, + valid_to DATETIME2 GENERATED ALWAYS AS ROW END NOT NULL, + PERIOD FOR SYSTEM_TIME (valid_from, valid_to) +) WITH (SYSTEM_VERSIONING = ON); diff --git a/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json b/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json new file mode 100644 index 0000000000..942935336f --- /dev/null +++ b/internal/endtoend/testdata/analyze_temporal/mssql/stdout.json @@ -0,0 +1,138 @@ +[ + { + "name": "PriceAsOf", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "prices" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "at", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + }, + { + "number": 2, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + } + } + ] + }, + { + "name": "PriceHistory", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "prices" + }, + { + "name": "amount", + "type": { + "name": "decimal", + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + }, + "table": "prices" + }, + { + "name": "valid_from", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + }, + "table": "prices" + }, + { + "name": "valid_to", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + }, + "table": "prices" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "from", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + }, + { + "number": 2, + "column": { + "name": "to", + "type": { + "name": "datetime2", + "args": [ + { + "int": 7 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json b/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql new file mode 100644 index 0000000000..320b95474b --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/query.sql @@ -0,0 +1,14 @@ +-- name: Converted :many +SELECT id, + TRY_CAST(raw AS INT) AS as_int, + TRY_CONVERT(DECIMAL(5,1), raw) AS as_decimal, + TRY_CAST(note AS NVARCHAR(MAX)) AS as_text +FROM readings +WHERE TRY_CAST(@min AS INT) > 0; + +-- name: Parsed :many +SELECT id, + TRY_PARSE(raw AS DECIMAL(10,2)) AS try_parsed, + TRY_PARSE(note AS DATETIME2 USING 'en-US') AS try_parsed_date +FROM readings +WHERE PARSE(@limit AS INT) > 0; diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql b/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql new file mode 100644 index 0000000000..ac4875448d --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/schema.sql @@ -0,0 +1,6 @@ +CREATE TABLE readings ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + raw VARCHAR(10) NOT NULL, + note VARCHAR(10), + amount DECIMAL(10,2) +); diff --git a/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json new file mode 100644 index 0000000000..7af70da068 --- /dev/null +++ b/internal/endtoend/testdata/analyze_try_conversions/mssql/stdout.json @@ -0,0 +1,116 @@ +[ + { + "name": "Converted", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "as_int", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "as_decimal", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 5 + }, + { + "int": 1 + } + ] + } + }, + { + "name": "as_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "min", + "type": { + "name": "int" + } + } + } + ] + }, + { + "name": "Parsed", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "readings" + }, + { + "name": "try_parsed", + "type": { + "name": "decimal", + "nullable": true, + "args": [ + { + "int": 10 + }, + { + "int": 2 + } + ] + } + }, + { + "name": "try_parsed_date", + "type": { + "name": "datetime2", + "nullable": true, + "args": [ + { + "int": 7 + } + ] + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "limit", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 4000 + } + ] + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json b/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql b/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql new file mode 100644 index 0000000000..0dd53b3f26 --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/query.sql @@ -0,0 +1,10 @@ +-- name: Methods :one +SELECT doc.value('(/a/@n)[1]', 'int') AS v, doc.value('(/a)[1]', 'nvarchar(20)') AS s, + doc.exist('/a') AS e, geo.STDistance(geo) AS dist, + geo.STAsText() AS txt, shape.ToString() AS shape_text, node.ToString() AS path, + node.GetLevel() AS lvl, node.GetAncestor(@up) AS anc, + hierarchyid::GetRoot() AS root, geography::Point(@lat, @long, 4326) AS pt +FROM m WHERE id = @id; + +-- name: Nearby :many +SELECT id FROM m WHERE geo.STDistance(geography::Point(@lat, @long, 4326)) < @meters AND node.IsDescendantOf(@ancestor) = 1; diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql b/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql new file mode 100644 index 0000000000..88b8cb4b7e --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE m (id INT NOT NULL, doc XML NOT NULL, geo GEOGRAPHY NOT NULL, shape GEOMETRY NULL, node HIERARCHYID NOT NULL); diff --git a/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json b/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json new file mode 100644 index 0000000000..c587ba6fbb --- /dev/null +++ b/internal/endtoend/testdata/analyze_type_methods/mssql/stdout.json @@ -0,0 +1,196 @@ +[ + { + "name": "Methods", + "cmd": ":one", + "columns": [ + { + "name": "v", + "type": { + "name": "int", + "nullable": true + } + }, + { + "name": "s", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 20 + } + ] + } + }, + { + "name": "e", + "type": { + "name": "bit", + "nullable": true + } + }, + { + "name": "dist", + "type": { + "name": "float", + "nullable": true + } + }, + { + "name": "txt", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "shape_text", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "ident": "max" + } + ] + } + }, + { + "name": "path", + "type": { + "name": "nvarchar", + "nullable": true, + "args": [ + { + "int": 4000 + } + ] + } + }, + { + "name": "lvl", + "type": { + "name": "smallint", + "nullable": true + } + }, + { + "name": "anc", + "type": { + "name": "hierarchyid", + "nullable": true + } + }, + { + "name": "root", + "type": { + "name": "hierarchyid", + "nullable": true + } + }, + { + "name": "pt", + "type": { + "name": "geography", + "nullable": true + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "up", + "type": { + "name": "int" + } + } + }, + { + "number": 2, + "column": { + "name": "lat", + "type": { + "name": "float" + } + } + }, + { + "number": 3, + "column": { + "name": "long", + "type": { + "name": "float" + } + } + }, + { + "number": 4, + "column": { + "name": "id", + "type": { + "name": "int" + }, + "table": "m" + } + } + ] + }, + { + "name": "Nearby", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "int" + }, + "table": "m" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "lat", + "type": { + "name": "float" + } + } + }, + { + "number": 2, + "column": { + "name": "long", + "type": { + "name": "float" + } + } + }, + { + "number": 3, + "column": { + "name": "meters", + "type": { + "name": "float", + "nullable": true + } + } + }, + { + "number": 4, + "column": { + "name": "ancestor", + "type": { + "name": "hierarchyid" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql new file mode 100644 index 0000000000..4b81abc310 --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: Negated :many +SELECT -CAST(i AS DECIMAL) AS nd, i - CAST(f AS DECIMAL(5,1)) AS diff, d * CAST(i AS DECIMAL(12,3)) AS product FROM p2; diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql new file mode 100644 index 0000000000..e1944ab1c9 --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE p2 (d DECIMAL(10,2) NOT NULL, i INT NOT NULL, f FLOAT NOT NULL); diff --git a/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json new file mode 100644 index 0000000000..1256449c2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_uninterned_decimal/mssql/stdout.json @@ -0,0 +1,27 @@ +[ + { + "name": "Negated", + "cmd": ":many", + "columns": [ + { + "name": "nd", + "type": { + "name": "decimal" + } + }, + { + "name": "diff", + "type": { + "name": "decimal" + } + }, + { + "name": "product", + "type": { + "name": "decimal" + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/exec.json b/internal/endtoend/testdata/analyze_values_table/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/query.sql b/internal/endtoend/testdata/analyze_values_table/mssql/query.sql new file mode 100644 index 0000000000..a2224287b0 --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/query.sql @@ -0,0 +1,16 @@ +-- name: Weights :many +SELECT a.id, a.name, v.weight +FROM authors a +JOIN (VALUES (1, 10), (2, 20)) AS v(id, weight) ON v.id = a.id; + +-- name: Correlated :many +SELECT a.id, v.n +FROM authors a +CROSS APPLY (VALUES (1), (2)) v(n) +WHERE v.n < a.id; + +-- name: Lateral :many +SELECT a.id +FROM authors a +CROSS APPLY (VALUES (a.id), (a.id + 1)) v(n) +WHERE v.n > 1; diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql b/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql new file mode 100644 index 0000000000..3629635d2e --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/schema.sql @@ -0,0 +1,7 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL, + bio NVARCHAR(MAX), + royalties DECIMAL(10,2) NOT NULL, + created DATETIME2 NOT NULL +); diff --git a/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json b/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json new file mode 100644 index 0000000000..ed0b4e767a --- /dev/null +++ b/internal/endtoend/testdata/analyze_values_table/mssql/stdout.json @@ -0,0 +1,68 @@ +[ + { + "name": "Weights", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "name", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "authors" + }, + { + "name": "weight", + "type": { + "name": "int" + } + } + ], + "params": [] + }, + { + "name": "Correlated", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "n", + "type": { + "name": "int" + } + } + ], + "params": [] + }, + { + "name": "Lateral", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + } + ], + "params": [] + } +] diff --git a/internal/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/endtoend/testdata/core_types/mssql/go/models.go b/internal/endtoend/testdata/core_types/mssql/go/models.go index db1ac4d38e..0aa73a328a 100644 --- a/internal/endtoend/testdata/core_types/mssql/go/models.go +++ b/internal/endtoend/testdata/core_types/mssql/go/models.go @@ -8,13 +8,14 @@ import ( "database/sql" "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" ) type Thing struct { ID int64 - Price string - Amount sql.NullString - Plain sql.NullString + Price decimal.Decimal + Amount decimal.NullDecimal + Plain decimal.NullDecimal Body sql.NullString Title sql.NullString Code sql.NullString @@ -28,9 +29,9 @@ type Thing struct { F sql.NullFloat64 F53 sql.NullFloat64 R sql.NullFloat64 - M sql.NullString + M mssql.Money[decimal.NullDecimal] B sql.NullBool - U mssql.NullUniqueIdentifier + U *mssql.UniqueIdentifier X sql.NullString J sql.NullString Sv any diff --git a/internal/endtoend/testdata/core_types/mssql/go/query.sql.go b/internal/endtoend/testdata/core_types/mssql/go/query.sql.go index 1645f7911b..5ab804ada8 100644 --- a/internal/endtoend/testdata/core_types/mssql/go/query.sql.go +++ b/internal/endtoend/testdata/core_types/mssql/go/query.sql.go @@ -9,6 +9,9 @@ import ( "context" "database/sql" "time" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" ) const allTypes = `-- name: AllTypes :many @@ -91,21 +94,21 @@ WHERE CAST(@a AS DECIMAL(5,2)) > 0 ` type CastsParams struct { - A string + A decimal.Decimal B string C string D time.Time - E string + E mssql.Money[decimal.Decimal] F float32 G string } type CastsRow struct { - A sql.NullString + A decimal.NullDecimal B sql.NullString C sql.NullString D sql.NullTime - E sql.NullString + E mssql.Money[decimal.NullDecimal] F sql.NullFloat64 G sql.NullString } @@ -139,7 +142,7 @@ WHERE price = @price AND body = @body AND phone = @phone AND offset_at = @offset ` type ParamsParams struct { - Price string + Price decimal.Decimal Body sql.NullString Phone any OffsetAt sql.NullTime diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql new file mode 100644 index 0000000000..8d1d2a89ef --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: CopyBooks :copyfrom +INSERT INTO books (id, title) VALUES (@id, @title); diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql new file mode 100644 index 0000000000..9e32b120d1 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT NOT NULL, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt new file mode 100644 index 0000000000..3509d2bee5 --- /dev/null +++ b/internal/endtoend/testdata/mssql_copyfrom_unsupported/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +error generating code: :copyfrom is only supported by pgx and github.com/go-sql-driver/mysql diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json b/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql b/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql new file mode 100644 index 0000000000..b5dd9a8bca --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: Related :many +SELECT a.id, r.title +FROM authors a +CROSS APPLY ( + SELECT title FROM books WHERE author_id = a.id + UNION ALL + SELECT name FROM authors WHERE id = a.id +) r; diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql b/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql new file mode 100644 index 0000000000..2a49202aaa --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json new file mode 100644 index 0000000000..addc234e68 --- /dev/null +++ b/internal/endtoend/testdata/mssql_correlated_union/mssql/stdout.json @@ -0,0 +1,27 @@ +[ + { + "name": "Related", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "authors" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 200 + } + ] + } + } + ], + "params": [] + } +] diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go new file mode 100644 index 0000000000..33cf3d5142 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/models.go @@ -0,0 +1,20 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int32 + Name string +} + +type Book struct { + ID int32 + AuthorID int32 + Title sql.NullString +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go new file mode 100644 index 0000000000..2463659348 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/go/query.sql.go @@ -0,0 +1,51 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const authorBooks = `-- name: AuthorBooks :many +SELECT a.id, a.name, b.id, b.author_id, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type AuthorBooksRow struct { + Author Author + ID sql.NullInt32 + AuthorID sql.NullInt32 + Title sql.NullString +} + +func (q *Queries) AuthorBooks(ctx context.Context) ([]AuthorBooksRow, error) { + rows, err := q.db.QueryContext(ctx, authorBooks) + if err != nil { + return nil, err + } + defer rows.Close() + var items []AuthorBooksRow + for rows.Next() { + var i AuthorBooksRow + if err := rows.Scan( + &i.Author.ID, + &i.Author.Name, + &i.ID, + &i.AuthorID, + &i.Title, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql new file mode 100644 index 0000000000..bd127e839d --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: AuthorBooks :many +SELECT sqlc.embed(a), sqlc.embed(b) FROM authors a LEFT JOIN books b ON b.author_id = a.id; diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql new file mode 100644 index 0000000000..7aaba24c5a --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(10) NOT NULL); +CREATE TABLE books (id INT NOT NULL, author_id INT NOT NULL, title NVARCHAR(20) NULL); diff --git a/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_embed_outer_join/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql new file mode 100644 index 0000000000..d1caf2a305 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/query.sql @@ -0,0 +1,2 @@ +-- name: CreateBook :execlastid +INSERT INTO books (id, title) VALUES (@id, @title); diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql new file mode 100644 index 0000000000..9e32b120d1 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT NOT NULL, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt new file mode 100644 index 0000000000..73b2d2edf0 --- /dev/null +++ b/internal/endtoend/testdata/mssql_execlastid_unsupported/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +error generating code: query "CreateBook": :execlastid is not supported for SQL Server, whose driver reports no last insert ID; use OUTPUT INSERTED. with :one diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json b/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go new file mode 100644 index 0000000000..32a015b046 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/models.go @@ -0,0 +1,10 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Book struct { + ID int32 + Title string +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go new file mode 100644 index 0000000000..cfee736040 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/go/query.sql.go @@ -0,0 +1,70 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const searchBooks = `-- name: SearchBooks :many +SELECT id, title FROM books WHERE CONTAINS(title, @query); +` + +func (q *Queries) SearchBooks(ctx context.Context, query string) ([]Book, error) { + rows, err := q.db.QueryContext(ctx, searchBooks, sql.Named("query", query)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Book + for rows.Next() { + var i Book + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const searchBooksFreeText = `-- name: SearchBooksFreeText :many +SELECT id, title FROM books WHERE FREETEXT(title, @phrase, LANGUAGE 1033) AND id > @min_id; +` + +type SearchBooksFreeTextParams struct { + Phrase string + MinID int32 +} + +func (q *Queries) SearchBooksFreeText(ctx context.Context, arg SearchBooksFreeTextParams) ([]Book, error) { + rows, err := q.db.QueryContext(ctx, searchBooksFreeText, sql.Named("phrase", arg.Phrase), sql.Named("min_id", arg.MinID)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Book + for rows.Next() { + var i Book + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql b/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql new file mode 100644 index 0000000000..66a83e8708 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: SearchBooks :many +SELECT id, title FROM books WHERE CONTAINS(title, @query); + +-- name: SearchBooksFreeText :many +SELECT id, title FROM books WHERE FREETEXT(title, @phrase, LANGUAGE 1033) AND id > @min_id; diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql b/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql new file mode 100644 index 0000000000..baa6ed3a42 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE books (id INT PRIMARY KEY, title NVARCHAR(200) NOT NULL); diff --git a/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_fulltext_params/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json b/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go new file mode 100644 index 0000000000..927a05454c --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/models.go @@ -0,0 +1,16 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Author struct { + ID int64 + Name string +} + +type Book struct { + ID int64 + AuthorID int64 + Title string +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go new file mode 100644 index 0000000000..cb22db28e4 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/go/query.sql.go @@ -0,0 +1,147 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const fullJoin = `-- name: FullJoin :many +SELECT a.name, b.title FROM authors a FULL OUTER JOIN books b ON b.author_id = a.id; +` + +type FullJoinRow struct { + Name sql.NullString + Title sql.NullString +} + +func (q *Queries) FullJoin(ctx context.Context) ([]FullJoinRow, error) { + rows, err := q.db.QueryContext(ctx, fullJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []FullJoinRow + for rows.Next() { + var i FullJoinRow + if err := rows.Scan(&i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const leftJoin = `-- name: LeftJoin :many +SELECT a.id, a.name, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type LeftJoinRow struct { + ID int64 + Name string + Title sql.NullString +} + +func (q *Queries) LeftJoin(ctx context.Context) ([]LeftJoinRow, error) { + rows, err := q.db.QueryContext(ctx, leftJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []LeftJoinRow + for rows.Next() { + var i LeftJoinRow + if err := rows.Scan(&i.ID, &i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const leftJoinStar = `-- name: LeftJoinStar :many +SELECT a.name, b.id, b.author_id, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; +` + +type LeftJoinStarRow struct { + Name string + ID sql.NullInt64 + AuthorID sql.NullInt64 + Title sql.NullString +} + +func (q *Queries) LeftJoinStar(ctx context.Context) ([]LeftJoinStarRow, error) { + rows, err := q.db.QueryContext(ctx, leftJoinStar) + if err != nil { + return nil, err + } + defer rows.Close() + var items []LeftJoinStarRow + for rows.Next() { + var i LeftJoinStarRow + if err := rows.Scan( + &i.Name, + &i.ID, + &i.AuthorID, + &i.Title, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const rightJoin = `-- name: RightJoin :many +SELECT a.name, b.title FROM authors a RIGHT JOIN books b ON b.author_id = a.id; +` + +type RightJoinRow struct { + Name sql.NullString + Title string +} + +func (q *Queries) RightJoin(ctx context.Context) ([]RightJoinRow, error) { + rows, err := q.db.QueryContext(ctx, rightJoin) + if err != nil { + return nil, err + } + defer rows.Close() + var items []RightJoinRow + for rows.Next() { + var i RightJoinRow + if err := rows.Scan(&i.Name, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql b/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql new file mode 100644 index 0000000000..c9696e994a --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/query.sql @@ -0,0 +1,11 @@ +-- name: LeftJoin :many +SELECT a.id, a.name, b.title FROM authors a LEFT JOIN books b ON b.author_id = a.id; + +-- name: RightJoin :many +SELECT a.name, b.title FROM authors a RIGHT JOIN books b ON b.author_id = a.id; + +-- name: FullJoin :many +SELECT a.name, b.title FROM authors a FULL OUTER JOIN books b ON b.author_id = a.id; + +-- name: LeftJoinStar :many +SELECT a.name, b.* FROM authors a LEFT JOIN books b ON b.author_id = a.id; diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql b/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql new file mode 100644 index 0000000000..754abf3290 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/schema.sql @@ -0,0 +1,10 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_outer_join/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json b/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go new file mode 100644 index 0000000000..d83c9edeab --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/models.go @@ -0,0 +1,24 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" + + "github.com/shopspring/decimal" +) + +type Author struct { + ID int64 + Name string + Bio sql.NullString +} + +type Book struct { + ID int64 + AuthorID int64 + Title string + Price decimal.NullDecimal +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go new file mode 100644 index 0000000000..76833127fa --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/go/query.sql.go @@ -0,0 +1,123 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const createBook = `-- name: CreateBook :one +INSERT INTO books (id, author_id, title) OUTPUT inserted.id, inserted.author_id, inserted.title, inserted.price VALUES (@id, @author_id, @title); +` + +type CreateBookParams struct { + ID int64 + AuthorID int64 + Title string +} + +func (q *Queries) CreateBook(ctx context.Context, arg CreateBookParams) (Book, error) { + row := q.db.QueryRowContext(ctx, createBook, sql.Named("id", arg.ID), sql.Named("author_id", arg.AuthorID), sql.Named("title", arg.Title)) + var i Book + err := row.Scan( + &i.ID, + &i.AuthorID, + &i.Title, + &i.Price, + ) + return i, err +} + +const deleteBook = `-- name: DeleteBook :one +DELETE FROM books OUTPUT deleted.id, deleted.author_id, deleted.title, deleted.price WHERE id = @id; +` + +func (q *Queries) DeleteBook(ctx context.Context, id int64) (Book, error) { + row := q.db.QueryRowContext(ctx, deleteBook, sql.Named("id", id)) + var i Book + err := row.Scan( + &i.ID, + &i.AuthorID, + &i.Title, + &i.Price, + ) + return i, err +} + +const deleteByAuthor = `-- name: DeleteByAuthor :many +DELETE b OUTPUT DELETED.id, DELETED.title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; +` + +type DeleteByAuthorRow struct { + ID int64 + Title string +} + +func (q *Queries) DeleteByAuthor(ctx context.Context, name string) ([]DeleteByAuthorRow, error) { + rows, err := q.db.QueryContext(ctx, deleteByAuthor, sql.Named("name", name)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []DeleteByAuthorRow + for rows.Next() { + var i DeleteByAuthorRow + if err := rows.Scan(&i.ID, &i.Title); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const retitleByAuthor = `-- name: RetitleByAuthor :many +UPDATE b SET title = @title +OUTPUT INSERTED.id, DELETED.title AS old_title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; +` + +type RetitleByAuthorParams struct { + Title string + Name string +} + +type RetitleByAuthorRow struct { + ID int64 + OldTitle string +} + +func (q *Queries) RetitleByAuthor(ctx context.Context, arg RetitleByAuthorParams) ([]RetitleByAuthorRow, error) { + rows, err := q.db.QueryContext(ctx, retitleByAuthor, sql.Named("title", arg.Title), sql.Named("name", arg.Name)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []RetitleByAuthorRow + for rows.Next() { + var i RetitleByAuthorRow + if err := rows.Scan(&i.ID, &i.OldTitle); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql b/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql new file mode 100644 index 0000000000..c08f806278 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/query.sql @@ -0,0 +1,16 @@ +-- name: CreateBook :one +INSERT INTO books (id, author_id, title) OUTPUT INSERTED.* VALUES (@id, @author_id, @title); + +-- name: RetitleByAuthor :many +UPDATE b SET title = @title +OUTPUT INSERTED.id, DELETED.title AS old_title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; + +-- name: DeleteByAuthor :many +DELETE b OUTPUT DELETED.id, DELETED.title +FROM books b JOIN authors a ON a.id = b.author_id +WHERE a.name = @name; + +-- name: DeleteBook :one +DELETE FROM books OUTPUT DELETED.* WHERE id = @id; diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql b/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql new file mode 100644 index 0000000000..28e9d45cf4 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/schema.sql @@ -0,0 +1,2 @@ +CREATE TABLE authors (id BIGINT IDENTITY(1,1) PRIMARY KEY, name NVARCHAR(100) NOT NULL, bio NVARCHAR(MAX)); +CREATE TABLE books (id BIGINT PRIMARY KEY, author_id BIGINT NOT NULL, title NVARCHAR(200) NOT NULL, price DECIMAL(10,2)); diff --git a/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_output_clause/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json b/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go new file mode 100644 index 0000000000..6ef0b67e36 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/models.go @@ -0,0 +1,11 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +type Sale struct { + AuthorID int32 + Year int32 + Amount int32 +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go new file mode 100644 index 0000000000..fecf1691be --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/go/query.sql.go @@ -0,0 +1,103 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const leadingUnicodeDigit = `-- name: LeadingUnicodeDigit :many +SELECT amount AS [١total] FROM sales; +` + +func (q *Queries) LeadingUnicodeDigit(ctx context.Context) ([]int32, error) { + rows, err := q.db.QueryContext(ctx, leadingUnicodeDigit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []int32 + for rows.Next() { + var _١total int32 + if err := rows.Scan(&_١total); err != nil { + return nil, err + } + items = append(items, _١total) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const noIdentifierCharacters = `-- name: NoIdentifierCharacters :many +SELECT amount AS [!] FROM sales; +` + +func (q *Queries) NoIdentifierCharacters(ctx context.Context) ([]int32, error) { + rows, err := q.db.QueryContext(ctx, noIdentifierCharacters) + if err != nil { + return nil, err + } + defer rows.Close() + var items []int32 + for rows.Next() { + var column_1 int32 + if err := rows.Scan(&column_1); err != nil { + return nil, err + } + items = append(items, column_1) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const sales2023 = `-- name: Sales2023 :many +SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; +` + +func (q *Queries) Sales2023(ctx context.Context) ([]sql.NullInt32, error) { + rows, err := q.db.QueryContext(ctx, sales2023) + if err != nil { + return nil, err + } + defer rows.Close() + var items []sql.NullInt32 + for rows.Next() { + var _2023 sql.NullInt32 + if err := rows.Scan(&_2023); err != nil { + return nil, err + } + items = append(items, _2023) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const totalForAuthor = `-- name: TotalForAuthor :one +SELECT [total amount] = SUM(amount) FROM sales WHERE author_id = @author_id; +` + +func (q *Queries) TotalForAuthor(ctx context.Context, authorID int32) (sql.NullInt32, error) { + row := q.db.QueryRowContext(ctx, totalForAuthor, sql.Named("author_id", authorID)) + var total_amount sql.NullInt32 + err := row.Scan(&total_amount) + return total_amount, err +} diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql new file mode 100644 index 0000000000..3e8cf1be87 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql @@ -0,0 +1,11 @@ +-- name: Sales2023 :many +SELECT pv.[2023] FROM sales PIVOT (SUM(amount) FOR year IN ([2023])) pv; + +-- name: TotalForAuthor :one +SELECT [total amount] = SUM(amount) FROM sales WHERE author_id = @author_id; + +-- name: LeadingUnicodeDigit :many +SELECT amount AS [١total] FROM sales; + +-- name: NoIdentifierCharacters :many +SELECT amount AS [!] FROM sales; diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql b/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql new file mode 100644 index 0000000000..9017ffc1b3 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE sales ( + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go new file mode 100644 index 0000000000..4073af03ce --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/models.go @@ -0,0 +1,21 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int64 + Name string + Bio sql.NullString +} + +type Book struct { + ID int64 + AuthorID int64 + Title string +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go new file mode 100644 index 0000000000..4bad0e6fab --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/go/query.sql.go @@ -0,0 +1,303 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" + "strconv" + "strings" +) + +const authorBooks = `-- name: AuthorBooks :many +SELECT a.id, a.name, a.bio, books.id, books.author_id, books.title, books.title AS book_title +FROM authors a JOIN books ON books.author_id = a.id +WHERE a.id = @author_id +ORDER BY books.id; +` + +type AuthorBooksRow struct { + Author Author + Book Book + BookTitle string +} + +func (q *Queries) AuthorBooks(ctx context.Context, authorID int64) ([]AuthorBooksRow, error) { + rows, err := q.db.QueryContext(ctx, authorBooks, sql.Named("author_id", authorID)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []AuthorBooksRow + for rows.Next() { + var i AuthorBooksRow + if err := rows.Scan( + &i.Author.ID, + &i.Author.Name, + &i.Author.Bio, + &i.Book.ID, + &i.Book.AuthorID, + &i.Book.Title, + &i.BookTitle, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const createAuthor = `-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (@id, @name, @bio); +` + +type CreateAuthorParams struct { + ID int64 + Name string + Bio sql.NullString +} + +func (q *Queries) CreateAuthor(ctx context.Context, arg CreateAuthorParams) error { + _, err := q.db.ExecContext(ctx, createAuthor, sql.Named("id", arg.ID), sql.Named("name", arg.Name), sql.Named("bio", arg.Bio)) + return err +} + +const embedNarrowSubquery = `-- name: EmbedNarrowSubquery :many +SELECT x.id, x.name FROM (SELECT id, name FROM authors) x; +` + +type EmbedNarrowSubqueryRow struct { + ID int64 + Name string +} + +func (q *Queries) EmbedNarrowSubquery(ctx context.Context) ([]EmbedNarrowSubqueryRow, error) { + rows, err := q.db.QueryContext(ctx, embedNarrowSubquery) + if err != nil { + return nil, err + } + defer rows.Close() + var items []EmbedNarrowSubqueryRow + for rows.Next() { + var i EmbedNarrowSubqueryRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const embedReorderedSubquery = `-- name: EmbedReorderedSubquery :many +SELECT x.name, x.id, x.bio FROM (SELECT name, id, bio FROM authors) x; +` + +type EmbedReorderedSubqueryRow struct { + Name string + ID int64 + Bio sql.NullString +} + +func (q *Queries) EmbedReorderedSubquery(ctx context.Context) ([]EmbedReorderedSubqueryRow, error) { + rows, err := q.db.QueryContext(ctx, embedReorderedSubquery) + if err != nil { + return nil, err + } + defer rows.Close() + var items []EmbedReorderedSubqueryRow + for rows.Next() { + var i EmbedReorderedSubqueryRow + if err := rows.Scan(&i.Name, &i.ID, &i.Bio); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAuthorsByIDs = `-- name: ListAuthorsByIDs :many +SELECT id, name FROM authors WHERE id IN (/*SLICE:ids*/@ids) ORDER BY id; +` + +type ListAuthorsByIDsRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDs(ctx context.Context, ids []int64) ([]ListAuthorsByIDsRow, error) { + query := listAuthorsByIDs + var queryParams []any + if len(ids) > 0 { + var placeholders []string + for _, v := range ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsRow + for rows.Next() { + var i ListAuthorsByIDsRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAuthorsByIDsAndName = `-- name: ListAuthorsByIDsAndName :many +SELECT id, name FROM authors WHERE name <> @name AND id IN (/*SLICE:ids*/@ids) AND bio IS NULL ORDER BY id; +` + +type ListAuthorsByIDsAndNameParams struct { + Name string + Ids []int64 +} + +type ListAuthorsByIDsAndNameRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDsAndName(ctx context.Context, arg ListAuthorsByIDsAndNameParams) ([]ListAuthorsByIDsAndNameRow, error) { + query := listAuthorsByIDsAndName + var queryParams []any + queryParams = append(queryParams, sql.Named("name", arg.Name)) + if len(arg.Ids) > 0 { + var placeholders []string + for _, v := range arg.Ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsAndNameRow + for rows.Next() { + var i ListAuthorsByIDsAndNameRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAuthorsByIDsTwice = `-- name: ListAuthorsByIDsTwice :many +SELECT id, name FROM authors WHERE id IN (/*SLICE:ids*/@ids) OR id + 100 IN (/*SLICE:ids*/@ids); +` + +type ListAuthorsByIDsTwiceRow struct { + ID int64 + Name string +} + +func (q *Queries) ListAuthorsByIDsTwice(ctx context.Context, ids []int64) ([]ListAuthorsByIDsTwiceRow, error) { + query := listAuthorsByIDsTwice + var queryParams []any + if len(ids) > 0 { + var placeholders []string + for _, v := range ids { + queryParams = append(queryParams, v) + placeholders = append(placeholders, "@p"+strconv.Itoa(len(queryParams))) + } + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", strings.Join(placeholders, ",")) + } else { + query = strings.ReplaceAll(query, "/*SLICE:ids*/@ids", "NULL") + } + rows, err := q.db.QueryContext(ctx, query, queryParams...) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ListAuthorsByIDsTwiceRow + for rows.Next() { + var i ListAuthorsByIDsTwiceRow + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const rowCount = `-- name: RowCount :one +SELECT CAST(@@ROWCOUNT AS INT) AS row_count; +` + +func (q *Queries) RowCount(ctx context.Context) (int32, error) { + row := q.db.QueryRowContext(ctx, rowCount) + var row_count int32 + err := row.Scan(&row_count) + return row_count, err +} + +const updateBio = `-- name: UpdateBio :execrows +UPDATE authors SET bio = @bio WHERE id = @id; +` + +type UpdateBioParams struct { + Bio sql.NullString + ID int64 +} + +func (q *Queries) UpdateBio(ctx context.Context, arg UpdateBioParams) (int64, error) { + result, err := q.db.ExecContext(ctx, updateBio, sql.Named("bio", arg.Bio), sql.Named("id", arg.ID)) + if err != nil { + return 0, err + } + return result.RowsAffected() +} diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql new file mode 100644 index 0000000000..3c973ed232 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/query.sql @@ -0,0 +1,29 @@ +-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (sqlc.arg(id), sqlc.arg(name), sqlc.narg(bio)); + +-- name: UpdateBio :execrows +UPDATE authors SET bio = sqlc.narg(bio) WHERE id = @id; + +-- name: ListAuthorsByIDs :many +SELECT id, name FROM authors WHERE id IN (sqlc.slice(ids)) ORDER BY id; + +-- name: ListAuthorsByIDsAndName :many +SELECT id, name FROM authors WHERE name <> @name AND id IN (sqlc.slice(ids)) AND bio IS NULL ORDER BY id; + +-- name: RowCount :one +SELECT CAST(@@ROWCOUNT AS INT) AS row_count; + +-- name: AuthorBooks :many +SELECT sqlc.embed(a), sqlc.embed(books), books.title AS book_title +FROM authors a JOIN books ON books.author_id = a.id +WHERE a.id = sqlc.arg(author_id) +ORDER BY books.id; + +-- name: ListAuthorsByIDsTwice :many +SELECT id, name FROM authors WHERE id IN (sqlc.slice(ids)) OR id + 100 IN (sqlc.slice(ids)); + +-- name: EmbedNarrowSubquery :many +SELECT sqlc.embed(x) FROM (SELECT id, name FROM authors) x; + +-- name: EmbedReorderedSubquery :many +SELECT sqlc.embed(x) FROM (SELECT name, id, bio FROM authors) x; diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql new file mode 100644 index 0000000000..95887bf36e --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE authors ( + id BIGINT PRIMARY KEY, + name NVARCHAR(50) NOT NULL, + bio NVARCHAR(MAX) +); + +CREATE TABLE books ( + id BIGINT PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(100) NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_sqlc_macros/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go new file mode 100644 index 0000000000..4167d53357 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/models.go @@ -0,0 +1,14 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Author struct { + ID int32 + Name sql.NullString +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go new file mode 100644 index 0000000000..6a06f8caa8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/go/query.sql.go @@ -0,0 +1,91 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" +) + +const a = `-- name: A :many +SELECT [a"b].id, [a"b].name FROM authors AS "a""b"; +` + +func (q *Queries) A(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, a) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const b = `-- name: B :many +SELECT [x]]y].id, [x]]y].name FROM authors AS "x]y"; +` + +func (q *Queries) B(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, b) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const c = `-- name: C :many +SELECT [x]]y].id, [x]]y].name FROM authors AS [x]]y]; +` + +func (q *Queries) C(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, c) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql new file mode 100644 index 0000000000..37705849ae --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: A :many +SELECT "a""b".* FROM authors AS "a""b"; + +-- name: B :many +SELECT "x]y".* FROM authors AS "x]y"; + +-- name: C :many +SELECT [x]]y].* FROM authors AS [x]]y]; diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql new file mode 100644 index 0000000000..531179cece --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE authors (id INT NOT NULL, name NVARCHAR(10) NULL); diff --git a/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_escaped_qualifier/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json b/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...any) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go new file mode 100644 index 0000000000..a5ecb804af --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/models.go @@ -0,0 +1,21 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "database/sql" +) + +type Order struct { + ID int32 + Select string + WeirdName sql.NullInt32 +} + +type Sale struct { + AuthorID int32 + Year int32 + Amount int32 +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go new file mode 100644 index 0000000000..f145d188af --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/go/query.sql.go @@ -0,0 +1,98 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" +) + +const listOrders = `-- name: ListOrders :many +SELECT o.id, o.[select], o.[weird]]name] FROM [order] o; +` + +func (q *Queries) ListOrders(ctx context.Context) ([]Order, error) { + rows, err := q.db.QueryContext(ctx, listOrders) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Order + for rows.Next() { + var i Order + if err := rows.Scan(&i.ID, &i.Select, &i.WeirdName); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listOrdersDoubleQuoted = `-- name: ListOrdersDoubleQuoted :many +SELECT o.id, o.[select], o.[weird]]name] FROM [order] "o"; +` + +func (q *Queries) ListOrdersDoubleQuoted(ctx context.Context) ([]Order, error) { + rows, err := q.db.QueryContext(ctx, listOrdersDoubleQuoted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Order + for rows.Next() { + var i Order + if err := rows.Scan(&i.ID, &i.Select, &i.WeirdName); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const salesByYear = `-- name: SalesByYear :many +SELECT pv.author_id, pv.[2023], pv.[2024] FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; +` + +type SalesByYearRow struct { + AuthorID int32 + _2023 sql.NullInt32 + _2024 sql.NullInt32 +} + +func (q *Queries) SalesByYear(ctx context.Context) ([]SalesByYearRow, error) { + rows, err := q.db.QueryContext(ctx, salesByYear) + if err != nil { + return nil, err + } + defer rows.Close() + var items []SalesByYearRow + for rows.Next() { + var i SalesByYearRow + if err := rows.Scan(&i.AuthorID, &i._2023, &i._2024); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql new file mode 100644 index 0000000000..8f19dc927f --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: ListOrders :many +SELECT o.* FROM [order] o; + +-- name: SalesByYear :many +SELECT pv.* FROM sales PIVOT (SUM(amount) FOR year IN ([2023], [2024])) pv; + +-- name: ListOrdersDoubleQuoted :many +SELECT "o".* FROM [order] "o"; diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql b/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql new file mode 100644 index 0000000000..67eb0ffc8a --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE [order] ( + id INT PRIMARY KEY, + [select] NVARCHAR(10) NOT NULL, + [weird]]name] INT +); + +CREATE TABLE sales ( + author_id INT NOT NULL, + year INT NOT NULL, + amount INT NOT NULL +); diff --git a/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_star_quoting/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json b/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json new file mode 100644 index 0000000000..253b05abbf --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/exec.json @@ -0,0 +1,5 @@ +{ + "command": "analyze", + "args": ["--dialect", "mssql", "--schema", "schema.sql", "query.sql"], + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql b/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql new file mode 100644 index 0000000000..16c0c69a27 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/query.sql @@ -0,0 +1,6 @@ +-- name: ByIDs :many +SELECT id, title FROM documents +WHERE id IN (SELECT CAST(value AS BIGINT) FROM STRING_SPLIT(@ids, ',')); + +-- name: Tokens :many +SELECT value FROM STRING_SPLIT(@list, ','); diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql b/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql new file mode 100644 index 0000000000..f70422d2a7 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE documents ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + title NVARCHAR(100) NOT NULL, + body NVARCHAR(MAX) +); diff --git a/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json b/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json new file mode 100644 index 0000000000..430beca540 --- /dev/null +++ b/internal/endtoend/testdata/mssql_string_split_param/mssql/stdout.json @@ -0,0 +1,61 @@ +[ + { + "name": "ByIDs", + "cmd": ":many", + "columns": [ + { + "name": "id", + "type": { + "name": "bigint" + }, + "table": "documents" + }, + { + "name": "title", + "type": { + "name": "nvarchar", + "args": [ + { + "int": 100 + } + ] + }, + "table": "documents" + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "ids", + "type": { + "name": "varchar" + } + } + } + ] + }, + { + "name": "Tokens", + "cmd": ":many", + "columns": [ + { + "name": "value", + "type": { + "name": "varchar" + } + } + ], + "params": [ + { + "number": 1, + "column": { + "name": "list", + "type": { + "name": "varchar" + } + } + } + ] + } +] diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql new file mode 100644 index 0000000000..6376e1f909 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/query.sql @@ -0,0 +1,5 @@ +-- name: Ids :many +SELECT id FROM t WHERE name = '@not_a_param' /* @nor_this */ AND id > @min; + +-- name: Sample :many +SELECT id FROM t WITH (INDEX(@ix)); diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql new file mode 100644 index 0000000000..15ae02025c --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/schema.sql @@ -0,0 +1 @@ +CREATE TABLE t (id INT NOT NULL, name NVARCHAR(50) NULL); diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt new file mode 100644 index 0000000000..8303d18af0 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_placeholder/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:30: placeholder @ix is not supported where it is used diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql new file mode 100644 index 0000000000..00a92a27ec --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: ListAuthors :many +SELECT id, name FROM authors; + +-- name: UpsertAuthor :exec +MERGE authors AS t +USING (SELECT @id AS id, @name AS name) s ON t.id = s.id +WHEN MATCHED THEN UPDATE SET name = s.name +WHEN NOT MATCHED THEN INSERT (name) VALUES (s.name); diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql new file mode 100644 index 0000000000..00557ccd53 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/schema.sql @@ -0,0 +1,12 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); + +CREATE PROCEDURE list_authors AS SELECT id, name FROM authors; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt new file mode 100644 index 0000000000..531a736e9f --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:1: Merge statements are not supported diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json new file mode 100644 index 0000000000..f4e21983b6 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/exec.json @@ -0,0 +1 @@ +{"contexts": ["base"]} diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql new file mode 100644 index 0000000000..a4c10b1c8b --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/query.sql @@ -0,0 +1,7 @@ +/* name: ListAuthors :many */ +SELECT id, name FROM authors; + +/* name: DeleteAll :exec */ +MERGE authors AS t +USING (SELECT @id AS id) s ON t.id = s.id +WHEN MATCHED THEN DELETE; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql new file mode 100644 index 0000000000..00557ccd53 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/schema.sql @@ -0,0 +1,12 @@ +CREATE TABLE authors ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(100) NOT NULL +); + +CREATE TABLE books ( + id BIGINT IDENTITY(1,1) PRIMARY KEY, + author_id BIGINT NOT NULL, + title NVARCHAR(200) NOT NULL +); + +CREATE PROCEDURE list_authors AS SELECT id, name FROM authors; diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml new file mode 100644 index 0000000000..94b0dc8896 --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/sqlc.yaml @@ -0,0 +1,10 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + sql_package: "database/sql" diff --git a/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt new file mode 100644 index 0000000000..531a736e9f --- /dev/null +++ b/internal/endtoend/testdata/mssql_unsupported_statement_block_comment/mssql/stderr.txt @@ -0,0 +1,2 @@ +# package querytest +query.sql:5:1: Merge statements are not supported diff --git a/internal/engine/mssql/convert.go b/internal/engine/mssql/convert.go index bdef335bc6..a4c7d4f35f 100644 --- a/internal/engine/mssql/convert.go +++ b/internal/engine/mssql/convert.go @@ -1,11 +1,14 @@ package mssql import ( + "math" "strconv" "strings" + "unicode/utf16" tsql "github.com/sqlc-dev/teesql/ast" + "github.com/sqlc-dev/sqlc/internal/core" "github.com/sqlc-dev/sqlc/internal/sql/ast" ) @@ -17,6 +20,10 @@ type cc struct { // toByte maps a teesql UTF-16 code-unit offset to a byte offset in the // source, so Location fields agree with StmtLocation/StmtLen. toByte func(int) int + // fromExprs are expressions a FROM item holds that the AST has no place + // for, as FOR SYSTEM_TIME AS OF @t does, analyzed with the query's WHERE + // clause so a placeholder in them is still a parameter. + fromExprs []ast.Node } // loc returns a node's start offset in bytes, for the Location fields of the @@ -63,13 +70,57 @@ 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.CreateFunctionStatement: + return c.convertCreateFunctionStatement(n) + case *tsql.CreateSynonymStatement: + return c.convertCreateSynonymStatement(n) + case *tsql.AlterSchemaStatement: + return c.convertAlterSchemaStatement(n) case *tsql.CreateTypeUddtStatement: return c.convertCreateTypeUddtStatement(n) + case *tsql.CreateViewStatement: + 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. @@ -97,6 +148,17 @@ func (c *cc) convertSelectStatement(n *tsql.SelectStatement) ast.Node { if !ok { return stmt } + // A query's own FOR JSON or FOR XML result is a column with the name + // SQL Server gives it, and FOR XML is ntext there. + if qs, ok := n.QueryExpression.(*tsql.QuerySpecification); ok { + if tn := forClauseType(qs.ForClause, true); tn != nil { + res := sel.TargetList.Items[0].(*ast.ResTarget) + res.Val.(*ast.TypeCast).TypeName = nullableTypeName(tn) + if name := forClauseColumn(qs.ForClause, tn); name != "" { + res.Name = &name + } + } + } if with := c.convertWithClause(n.WithCtesAndXmlNamespaces); with != nil { sel.WithClause = with } @@ -107,9 +169,12 @@ func (c *cc) convertWithClause(n *tsql.WithCtesAndXmlNamespaces) *ast.WithClause if n == nil || len(n.CommonTableExpressions) == 0 { return nil } + // T-SQL has no RECURSIVE keyword: a common table expression that names + // itself is recursive. with := &ast.WithClause{ - Ctes: &ast.List{}, - Location: c.loc(n), + Ctes: &ast.List{}, + Recursive: true, + Location: c.loc(n), } for _, cte := range n.CommonTableExpressions { name := identifierValue(cte.ExpressionName) @@ -186,16 +251,26 @@ func (c *cc) convertQuerySpecification(n *tsql.QuerySpecification) *ast.SelectSt } } + outerFromExprs := c.fromExprs + c.fromExprs = nil if n.FromClause != nil { stmt.FromClause = &ast.List{} for _, ref := range n.FromClause.TableReferences { stmt.FromClause.Items = append(stmt.FromClause.Items, c.convertTableReference(ref)) } } + fromExprs := c.fromExprs + c.fromExprs = outerFromExprs if n.WhereClause != nil { stmt.WhereClause = c.convertBooleanExpression(n.WhereClause.SearchCondition) } + if len(fromExprs) > 0 { + if stmt.WhereClause != nil { + fromExprs = append([]ast.Node{stmt.WhereClause}, fromExprs...) + } + stmt.WhereClause = &ast.BoolExpr{Boolop: ast.BoolExprTypeAnd, Args: &ast.List{Items: fromExprs}} + } if n.GroupByClause != nil { stmt.GroupClause = &ast.List{} @@ -224,18 +299,76 @@ func (c *cc) convertQuerySpecification(n *tsql.QuerySpecification) *ast.SelectSt } } - // TOP n; TOP n PERCENT does not translate to a row count. - if n.TopRowFilter != nil && !n.TopRowFilter.Percent { + // TOP n. TOP n PERCENT is no row count, but a float a placeholder for + // it is typed as. + if n.TopRowFilter != nil { stmt.LimitCount = c.convertScalarExpression(n.TopRowFilter.Expression) + if n.TopRowFilter.Percent { + stmt.LimitCount = &ast.TypeCast{Arg: stmt.LimitCount, TypeName: &ast.TypeName{Name: "float"}} + } } if n.UniqueRowFilter == "Distinct" { stmt.DistinctClause = &ast.List{} } + if tn := forClauseType(n.ForClause, false); tn != nil { + return forClauseResult(stmt, tn, c.loc(n)) + } return stmt } +// forClauseResult is a query with FOR JSON or FOR XML as what it returns: a +// single nullable column of the document its rows make. The query itself is +// kept as a subquery, so its placeholders and stars are still analyzed. +func forClauseResult(query *ast.SelectStmt, tn *ast.TypeName, loc int) *ast.SelectStmt { + return &ast.SelectStmt{TargetList: &ast.List{Items: []ast.Node{&ast.ResTarget{ + Val: &ast.TypeCast{ + Arg: &ast.SubLink{SubLinkType: ast.EXPR_SUBLINK, Subselect: query, Location: loc}, + TypeName: nullableTypeName(tn), + Location: loc, + }, + Location: loc, + }}}} +} + +// forClauseType is the type of the document FOR JSON or FOR XML makes, or +// nil for any other FOR clause. FOR XML without TYPE is ntext as a query's +// result but nvarchar(max) as a subquery's. +func forClauseType(fc tsql.ForClause, topLevel bool) *ast.TypeName { + maxText := &ast.TypeName{Name: "nvarchar", Typmods: appendTypmod(nil, &ast.String{Str: "max"})} + switch f := fc.(type) { + case *tsql.JsonForClause: + return maxText + case *tsql.XmlForClause: + for _, o := range f.Options { + if o.OptionKind == "Type" { + return &ast.TypeName{Name: "xml"} + } + } + if topLevel { + return &ast.TypeName{Name: "ntext"} + } + return maxText + } + return nil +} + +// forClauseColumn is the name SQL Server gives the column FOR JSON or FOR +// XML returns, which XML with TYPE leaves unnamed. +func forClauseColumn(fc tsql.ForClause, tn *ast.TypeName) string { + switch { + case tn.Name == "xml": + return "" + case fc != nil: + if _, ok := fc.(*tsql.JsonForClause); ok { + return identifier("JSON_F52E2B61-18A1-11d1-B105-00805F49916B") + } + return identifier("XML_F52E2B61-18A1-11d1-B105-00805F49916B") + } + return "" +} + func (c *cc) convertSelectElement(elem tsql.SelectElement) ast.Node { switch e := elem.(type) { case *tsql.SelectScalarExpression: @@ -311,6 +444,30 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { alias := identifierValue(t.Alias) rv.Alias = &ast.Alias{Aliasname: &alias} } + // The times of FOR SYSTEM_TIME are the datetime2 SQL Server takes. + if tc := t.TemporalClause; tc != nil { + for _, e := range []tsql.ScalarExpression{tc.StartTime, tc.EndTime} { + if e != nil { + c.fromExprs = append(c.fromExprs, &ast.TypeCast{Arg: c.convertScalarExpression(e), TypeName: typeName("datetime2", 7)}) + } + } + } + // TABLESAMPLE takes a percentage as a float and a count of rows + // or a REPEATABLE seed as a bigint. + if ts := t.TableSampleClause; ts != nil { + size := "float" + if ts.TableSampleClauseOption == "Rows" { + size = "bigint" + } + for _, e := range []struct { + expr tsql.ScalarExpression + typ string + }{{ts.SampleNumber, size}, {ts.RepeatSeed, "bigint"}} { + if e.expr != nil { + c.fromExprs = append(c.fromExprs, &ast.TypeCast{Arg: c.convertScalarExpression(e.expr), TypeName: &ast.TypeName{Name: e.typ}}) + } + } + } return rv case *tsql.QueryDerivedTable: sub := &ast.RangeSubselect{ @@ -321,6 +478,8 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { sub.Alias = &ast.Alias{Aliasname: &alias} } return sub + case *tsql.InlineDerivedTable: + return c.convertInlineDerivedTable(t) case *tsql.QualifiedJoin: join := &ast.JoinExpr{ Larg: c.convertTableReference(t.FirstTableReference), @@ -341,19 +500,210 @@ func (c *cc) convertTableReference(ref tsql.TableReference) ast.Node { } return join case *tsql.UnqualifiedJoin: - if t.UnqualifiedJoinType != "CrossJoin" { - return todo(ref) + // APPLY is a lateral join: its right side may refer to the left, + // which the analyzer allows for every FROM item bound after another. + // OUTER APPLY keeps unmatched left rows, as a left join does. + join := &ast.JoinExpr{ + Larg: c.convertTableReference(t.FirstTableReference), + Rarg: c.convertTableReference(t.SecondTableReference), } - return &ast.JoinExpr{ - Jointype: ast.JoinTypeInner, - Larg: c.convertTableReference(t.FirstTableReference), - Rarg: c.convertTableReference(t.SecondTableReference), + switch t.UnqualifiedJoinType { + case "CrossJoin", "CrossApply": + join.Jointype = ast.JoinTypeInner + case "OuterApply": + join.Jointype = ast.JoinTypeLeft + default: + return todo(ref) } + return join + case *tsql.OpenJsonTableReference: + return c.convertOpenJson(t) + case *tsql.GlobalFunctionTableReference: + return c.convertGlobalFunctionTableReference(t) + case *tsql.SchemaObjectFunctionTableReference: + if t.SchemaObject == nil || t.SchemaObject.BaseIdentifier == nil { + return todo(t) + } + return c.rangeFunction(t, identifierValue(t.SchemaObject.BaseIdentifier), t.Parameters, t.Alias, nil) + case *tsql.PivotedTableReference: + return c.convertPivot(t) + case *tsql.UnpivotedTableReference: + return c.convertUnpivot(t) default: return todo(ref) } } +// convertPivot converts PIVOT. Its columns depend on those of its source, +// which only the analyzer knows, so it is passed on rather than rewritten +// as the grouped query it stands for. +func (c *cc) convertPivot(n *tsql.PivotedTableReference) ast.Node { + if n.AggregateFunctionIdentifier == nil || len(n.AggregateFunctionIdentifier.Identifiers) == 0 || n.PivotColumn == nil { + return todo(n) + } + ids := n.AggregateFunctionIdentifier.Identifiers + agg := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: identifierValue(ids[len(ids)-1])}}}, + Args: &ast.List{}, + Location: c.loc(n), + } + for _, col := range n.ValueColumns { + agg.Args.Items = append(agg.Args.Items, c.convertColumnReference(col)) + } + p := &ast.RangePivot{ + Source: c.convertTableReference(n.TableReference), + Aggregate: agg, + ForColumn: columnName(n.PivotColumn), + InList: &ast.List{}, + } + for _, id := range n.InColumns { + p.InList.Items = append(p.InList.Items, NewIdentifier(id.Value)) + } + if n.Alias != nil { + alias := identifierValue(n.Alias) + p.Alias = &ast.Alias{Aliasname: &alias} + } + return p +} + +// convertUnpivot converts UNPIVOT, which, as PIVOT, keeps the columns of +// its source the analyzer knows. +func (c *cc) convertUnpivot(n *tsql.UnpivotedTableReference) ast.Node { + p := &ast.RangePivot{ + Source: c.convertTableReference(n.TableReference), + Unpivot: true, + ValueColumn: identifierValue(n.ValueColumn), + ForColumn: identifierValue(n.PivotColumn), + ForType: typeName("nvarchar", 128), + InList: &ast.List{}, + } + for _, col := range n.InColumns { + p.InList.Items = append(p.InList.Items, &ast.String{Str: columnName(col)}) + } + if n.Alias != nil { + alias := identifierValue(n.Alias) + p.Alias = &ast.Alias{Aliasname: &alias} + } + return p +} + +// columnName is the name a column reference ends in. +func columnName(n *tsql.ColumnReferenceExpression) string { + if n == nil || n.MultiPartIdentifier == nil || len(n.MultiPartIdentifier.Identifiers) == 0 { + return "" + } + ids := n.MultiPartIdentifier.Identifiers + return identifierValue(ids[len(ids)-1]) +} + +// convertInlineDerivedTable converts (VALUES ...) AS v(a, b) to the +// subquery it stands for, its rows selected one after another with UNION +// ALL, so the relation's columns are typed from its first row. +func (c *cc) convertInlineDerivedTable(n *tsql.InlineDerivedTable) ast.Node { + var query *ast.SelectStmt + for _, row := range n.RowValues { + sel := &ast.SelectStmt{TargetList: &ast.List{}} + for _, val := range row.ColumnValues { + sel.TargetList.Items = append(sel.TargetList.Items, &ast.ResTarget{ + Val: c.convertScalarExpression(val), + Location: c.loc(val), + }) + } + if query == nil { + query = sel + continue + } + query = &ast.SelectStmt{Op: ast.Union, All: true, Larg: query, Rarg: sel} + } + if query == nil { + return todo(n) + } + sub := &ast.RangeSubselect{Subquery: query} + if n.Alias != nil { + alias := identifierValue(n.Alias) + sub.Alias = &ast.Alias{Aliasname: &alias, Colnames: &ast.List{}} + for _, col := range n.Columns { + sub.Alias.Colnames.Items = append(sub.Alias.Colnames.Items, NewIdentifier(col.Value)) + } + } + return sub +} + +// rangeFunction is a call in FROM to a function returning rows of the +// columns defs declares, or of its own columns when there are none. +func (c *cc) rangeFunction(n tsql.Node, name string, args []tsql.ScalarExpression, alias *tsql.Identifier, defs []ast.Node) *ast.RangeFunction { + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: name}}}, + Location: c.loc(n), + } + for _, arg := range args { + if call.Args == nil { + call.Args = &ast.List{} + } + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(arg)) + } + rf := &ast.RangeFunction{ + Functions: &ast.List{Items: []ast.Node{&ast.List{Items: []ast.Node{call}}}}, + } + if len(defs) > 0 { + rf.Coldeflist = &ast.List{Items: defs} + } + if alias != nil { + name := identifierValue(alias) + rf.Alias = &ast.Alias{Aliasname: &name} + } + return rf +} + +// convertOpenJson converts OPENJSON, whose rows are the key, value and type +// of each JSON element, or the columns its WITH clause declares. +func (c *cc) convertOpenJson(n *tsql.OpenJsonTableReference) ast.Node { + args := []tsql.ScalarExpression{n.Variable} + if n.RowPattern != nil { + args = append(args, n.RowPattern) + } + var defs []ast.Node + if len(n.SchemaDeclarationItems) == 0 { + defs = []ast.Node{ + &ast.ColumnDef{Colname: "key", TypeName: typeName("nvarchar", 4000), IsNotNull: true}, + &ast.ColumnDef{Colname: "value", TypeName: &ast.TypeName{Name: "nvarchar", Typmods: appendTypmod(nil, &ast.String{Str: "max"})}}, + &ast.ColumnDef{Colname: "type", TypeName: &ast.TypeName{Name: "tinyint"}, IsNotNull: true}, + } + } + for _, item := range n.SchemaDeclarationItems { + if item.ColumnDefinition == nil { + continue + } + defs = append(defs, &ast.ColumnDef{ + Colname: identifierValue(item.ColumnDefinition.ColumnIdentifier), + TypeName: dataTypeName(item.ColumnDefinition.DataType), + }) + } + return c.rangeFunction(n, "openjson", args, n.Alias, defs) +} + +// convertGlobalFunctionTableReference converts STRING_SPLIT and +// GENERATE_SERIES. Each returns a value of its seeded result type, and +// STRING_SPLIT with enable_ordinal set adds the ordinal of each. +func (c *cc) convertGlobalFunctionTableReference(n *tsql.GlobalFunctionTableReference) ast.Node { + name := identifierValue(n.Name) + defs := []ast.Node{&ast.ColumnDef{Colname: "value"}} + switch name { + case "string_split": + if len(n.Parameters) == 3 { + defs = append(defs, &ast.ColumnDef{Colname: "ordinal", TypeName: &ast.TypeName{Name: "bigint"}, IsNotNull: true}) + } + case "generate_series": + default: + return todo(n) + } + return c.rangeFunction(n, name, n.Parameters, n.Alias, defs) +} + +func typeName(name string, length int64) *ast.TypeName { + return &ast.TypeName{Name: name, Typmods: appendTypmod(nil, &ast.A_Const{Val: &ast.Integer{Ival: length}})} +} + func (c *cc) convertBooleanExpression(expr tsql.BooleanExpression) ast.Node { if expr == nil { return nil @@ -447,6 +797,18 @@ func (c *cc) convertBooleanExpression(expr tsql.BooleanExpression) ast.Node { } case *tsql.BooleanScalarPlaceholder: return c.convertScalarExpression(e.Scalar) + case *tsql.FullTextPredicate: + // CONTAINS and FREETEXT are the predicates the dialect seeds under + // their names, over their search condition and language term. + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: identifier(e.FullTextFunctionType)}}}, + Args: &ast.List{Items: []ast.Node{c.convertScalarExpression(e.Value)}}, + Location: c.loc(e), + } + if e.LanguageTerm != nil { + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(e.LanguageTerm)) + } + return call default: return todo(expr) } @@ -481,16 +843,16 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.VariableReference: return c.convertVariableReference(e) case *tsql.IntegerLiteral: - ival, _ := strconv.ParseInt(e.Value, 10, 64) + ival, err := strconv.ParseInt(e.Value, 10, 64) + if err != nil || ival > math.MaxInt32 { + return c.numericLiteral(e.Value, e) + } return &ast.A_Const{ Val: &ast.Integer{Ival: ival}, Location: c.loc(e), } case *tsql.NumericLiteral: - return &ast.A_Const{ - Val: &ast.Float{Str: e.Value}, - Location: c.loc(e), - } + return c.numericLiteral(e.Value, e) case *tsql.RealLiteral: return &ast.A_Const{ Val: &ast.Float{Str: e.Value}, @@ -502,10 +864,15 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Location: c.loc(e), } case *tsql.StringLiteral: - return &ast.A_Const{ + lit := &ast.A_Const{ Val: &ast.String{Str: e.Value}, Location: c.loc(e), } + // N'...' is an nvarchar as long as the string, and at least 1. + if e.IsNational { + return &ast.TypeCast{Arg: lit, TypeName: typeName("nvarchar", max(1, int64(len(utf16.Encode([]rune(e.Value)))))), Location: c.loc(e)} + } + return lit case *tsql.NullLiteral: return &ast.A_Const{ Val: &ast.Null{}, @@ -547,6 +914,14 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { case *tsql.ParenthesisExpression: return c.convertScalarExpression(e.Expression) case *tsql.FunctionCall: + if out := c.convertMethodCall(e); out != nil { + return out + } + if e.OverClause == nil { + if out := c.convertAlternatives(e); out != nil { + return out + } + } return c.convertFunctionCall(e) case *tsql.CastCall: return &ast.TypeCast{ @@ -555,23 +930,29 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Location: c.loc(e), } case *tsql.TryCastCall: - return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), - TypeName: dataTypeName(e.DataType), - Location: c.loc(e), - } + return c.tryCast(e.Parameter, e.DataType, e) + case *tsql.ParseCall: + return c.parseCall(e.StringValue, e.Culture, e.DataType, false, e) + case *tsql.TryParseCall: + return c.parseCall(e.StringValue, e.Culture, e.DataType, true, e) case *tsql.ConvertCall: - return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), - TypeName: dataTypeName(e.DataType), - Location: c.loc(e), + arg := c.convertScalarExpression(e.Parameter) + // A style given as other than a literal, as @style, is an int + // passed through "convert style", which may return NULL. + if _, literal := e.Style.(*tsql.IntegerLiteral); e.Style != nil && !literal { + arg = &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: "convert style"}}}, + Args: &ast.List{Items: []ast.Node{arg, &ast.TypeCast{Arg: c.convertScalarExpression(e.Style), TypeName: &ast.TypeName{Name: "int"}}}}, + Location: c.loc(e), + } } - case *tsql.TryConvertCall: return &ast.TypeCast{ - Arg: c.convertScalarExpression(e.Parameter), + Arg: arg, TypeName: dataTypeName(e.DataType), Location: c.loc(e), } + case *tsql.TryConvertCall: + return c.tryCast(e.Parameter, e.DataType, e) case *tsql.CoalesceExpression: coalesce := &ast.CoalesceExpr{ Args: &ast.List{}, @@ -644,6 +1025,42 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { Subselect: c.convertQueryExpression(e.QueryExpression), Location: c.loc(e), } + case *tsql.AtTimeZoneCall: + // x AT TIME ZONE tz is typed as the call the dialect seeds under a + // name no function can have. + return &ast.FuncCall{ + Funcname: &ast.List{ + Items: []ast.Node{&ast.String{Str: "at time zone"}}, + }, + Args: &ast.List{ + Items: []ast.Node{ + c.convertScalarExpression(e.DateValue), + c.convertScalarExpression(e.TimeZone), + }, + }, + Location: c.loc(e), + } + case *tsql.LeftFunctionCall: + return c.namedCall("left", e.Parameters, e) + case *tsql.RightFunctionCall: + return c.namedCall("right", e.Parameters, e) + case *tsql.NextValueForExpression: + if e.SequenceName == nil { + return todo(e) + } + return &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: sequenceFunc(e.SequenceName)}}}, + Location: c.loc(e), + } + case *tsql.GlobalVariableExpression: + // @@ROWCOUNT and its relatives are typed as the functions the + // dialect seeds under their names. + return &ast.FuncCall{ + Funcname: &ast.List{ + Items: []ast.Node{&ast.String{Str: identifier(e.Name)}}, + }, + Location: c.loc(e), + } case *tsql.ParameterlessCall: return &ast.FuncCall{ Funcname: &ast.List{ @@ -656,6 +1073,91 @@ func (c *cc) convertScalarExpression(expr tsql.ScalarExpression) ast.Node { } } +// tryCast converts TRY_CAST and TRY_CONVERT, which yield NULL for a value +// they cannot convert, so their result is nullable whatever the operand is. +// A placeholder cast this way is typed by the cast as it is by CAST. +func (c *cc) tryCast(arg tsql.ScalarExpression, dataType tsql.DataTypeReference, n tsql.Node) ast.Node { + return &ast.TypeCast{ + Arg: c.convertScalarExpression(arg), + TypeName: tryTypeName(arg, dataType), + Location: c.loc(n), + } +} + +// tryTypeName is the type a TRY_ conversion of arg yields: nullable, unless +// arg is a placeholder, which the conversion types as CAST does. +func tryTypeName(arg tsql.ScalarExpression, dataType tsql.DataTypeReference) *ast.TypeName { + if _, ok := arg.(*tsql.VariableReference); ok { + return dataTypeName(dataType) + } + return nullableTypeName(dataTypeName(dataType)) +} + +func nullableTypeName(tn *ast.TypeName) *ast.TypeName { + if t := core.TypeExprOfTypeName(tn); t != nil { + return &ast.TypeName{Spelling: "Nullable(" + t.String() + ")"} + } + return tn +} + +// parseCall converts PARSE and TRY_PARSE, which convert a string as CAST +// and TRY_CAST do. What they convert is a string, so a placeholder there is +// the nvarchar(4000) SQL Server takes it as. A culture is passed through a +// call, so a placeholder given for it is still a parameter of the query. +func (c *cc) parseCall(value, culture tsql.ScalarExpression, dataType tsql.DataTypeReference, try bool, n tsql.Node) ast.Node { + tn := dataTypeName(dataType) + if try { + tn = nullableTypeName(tn) + } + arg := c.convertScalarExpression(value) + if _, ok := value.(*tsql.VariableReference); ok { + arg = &ast.TypeCast{Arg: arg, TypeName: typeName("nvarchar", 4000), Location: c.loc(value)} + } + if culture != nil { + arg = &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: "parse"}}}, + Args: &ast.List{Items: []ast.Node{arg, c.convertScalarExpression(culture)}}, + Location: c.loc(n), + } + } + return &ast.TypeCast{Arg: arg, TypeName: tn, Location: c.loc(n)} +} + +// convertAlternatives converts the functions that yield one of their +// arguments, which SQL Server types as the type their candidates combine +// to, as it does CASE: GREATEST and LEAST, and CHOOSE, which is the CASE +// over its index it is defined as. ISNULL, NULL only when both arguments +// are, as COALESCE is, keeps its first argument's type. +func (c *cc) convertAlternatives(e *tsql.FunctionCall) ast.Node { + args := &ast.List{} + for _, p := range e.Parameters { + args.Items = append(args.Items, c.convertScalarExpression(p)) + } + switch identifierValue(e.FunctionName) { + case "isnull": + if len(args.Items) == 2 { + return &ast.CoalesceExpr{Args: args, FirstArgType: true, Location: c.loc(e)} + } + case "greatest": + return &ast.MinMaxExpr{Op: 0, Args: args, Location: c.loc(e)} + case "least": + return &ast.MinMaxExpr{Op: 1, Args: args, Location: c.loc(e)} + case "choose": + if len(args.Items) < 2 { + return nil + } + choose := &ast.CaseExpr{Arg: args.Items[0], Args: &ast.List{}, Location: c.loc(e)} + for i, item := range args.Items[1:] { + choose.Args.Items = append(choose.Args.Items, &ast.CaseWhen{ + Expr: &ast.A_Const{Val: &ast.Integer{Ival: int64(i + 1)}}, + Result: item, + }) + } + return choose + } + return nil +} + func binaryOperator(binaryExpressionType string) string { switch binaryExpressionType { case "Add": @@ -725,6 +1227,68 @@ type namedParam struct { name string } +// typeMethods are the methods of xml, geography, geometry and hierarchyid +// a query calls on a value, as doc.exist('/a') or node.GetLevel() do. A +// call to one is seeded as ".name" taking the value first, which tells it +// from a function in a schema, as dbo.f(), the parser sees alike. +var typeMethods = map[string]bool{ + "exist": true, + "getlevel": true, "tostring": true, "getancestor": true, "getdescendant": true, + "isdescendantof": true, "getreparentedvalue": true, + "stastext": true, "stasbinary": true, "starea": true, "stlength": true, + "stdistance": true, "stintersects": true, "stcontains": true, "stwithin": true, + "stequals": true, "stbuffer": true, "stunion": true, "stintersection": true, + "stnumpoints": true, "stgeometrytype": true, "stdimension": true, + "stisvalid": true, "stpointn": true, +} + +// convertMethodCall converts a call of a method on a value, or of a static +// one on a type, as geography::Point(...) is, seeded as "geography::point". +// xml's value(path, 'type') returns the type it names, or NULL when the +// path finds nothing. +func (c *cc) convertMethodCall(n *tsql.FunctionCall) ast.Node { + method := identifierValue(n.FunctionName) + var receiver ast.Node + switch t := n.CallTarget.(type) { + case *tsql.UserDefinedTypeCallTarget: + if t.SchemaObjectName == nil || t.SchemaObjectName.BaseIdentifier == nil { + return nil + } + fc := c.convertFunctionCall(n) + fc.Funcname = &ast.List{Items: []ast.Node{&ast.String{Str: identifierValue(t.SchemaObjectName.BaseIdentifier) + "::" + method}}} + return fc + case *tsql.MultiPartIdentifierCallTarget: + if t.MultiPartIdentifier == nil { + return nil + } + receiver = c.convertColumnReference(&tsql.ColumnReferenceExpression{MultiPartIdentifier: t.MultiPartIdentifier}) + case *tsql.ExpressionCallTarget: + receiver = c.convertScalarExpression(t.Expression) + default: + return nil + } + if method == "value" && len(n.Parameters) == 2 { + if lit, ok := n.Parameters[1].(*tsql.StringLiteral); ok { + return &ast.TypeCast{ + Arg: receiver, + TypeName: &ast.TypeName{Spelling: "Nullable(" + strings.ToLower(lit.Value) + ")"}, + Location: c.loc(n), + } + } + } + if !typeMethods[method] { + return nil + } + fc := c.convertFunctionCall(n) + fc.Funcname = &ast.List{Items: []ast.Node{&ast.String{Str: "." + method}}} + args := []ast.Node{receiver} + if fc.Args != nil { + args = append(args, fc.Args.Items...) + } + fc.Args = &ast.List{Items: args} + return fc +} + func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { fc := &ast.FuncCall{ Funcname: &ast.List{ @@ -734,7 +1298,15 @@ func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { AggDistinct: n.UniqueRowFilter == "Distinct", } - for _, param := range n.Parameters { + for i, param := range n.Parameters { + // The datepart DATEADD and its relatives take first is a keyword, + // not a column: it is passed on as the string it names. + if i == 0 && datepartFunctions[identifierValue(n.FunctionName)] { + if part := datepart(param); part != "" { + fc.Args = &ast.List{Items: []ast.Node{&ast.A_Const{Val: &ast.String{Str: part}, Location: c.loc(param)}}} + continue + } + } // COUNT(*) and friends carry the star as a wildcard column reference. if col, ok := param.(*tsql.ColumnReferenceExpression); ok && col.ColumnType == "Wildcard" && col.MultiPartIdentifier == nil { fc.AggStar = true @@ -762,37 +1334,42 @@ func (c *cc) convertFunctionCall(n *tsql.FunctionCall) *ast.FuncCall { return fc } +// datepartFunctions are the functions whose first argument is a datepart. +var datepartFunctions = map[string]bool{ + "dateadd": true, + "datediff": true, + "datediff_big": true, + "datename": true, + "datepart": true, + "datetrunc": true, + "date_bucket": true, +} + +// datepart returns the datepart keyword an argument spells, as in +// DATEADD(day, ...), or "" when it is not a bare name. +func datepart(n tsql.ScalarExpression) string { + col, ok := n.(*tsql.ColumnReferenceExpression) + if !ok || col.MultiPartIdentifier == nil || len(col.MultiPartIdentifier.Identifiers) != 1 { + return "" + } + return identifierValue(col.MultiPartIdentifier.Identifiers[0]) +} + // convertOutputClause converts an OUTPUT clause to a returning list. The -// INSERTED and DELETED pseudo-table qualifiers are stripped so the columns -// resolve against the statement's target table. +// dialect names INSERTED and DELETED as the target's aliases there, so the +// qualifiers are kept, and a star they qualify expands to columns they +// qualify too. func (c *cc) convertOutputClause(n *tsql.OutputClause) *ast.List { if n == nil || len(n.SelectColumns) == 0 { return nil } list := &ast.List{} for _, elem := range n.SelectColumns { - target := c.convertSelectElement(elem) - if res, ok := target.(*ast.ResTarget); ok { - stripOutputQualifier(res.Val) - } - list.Items = append(list.Items, target) + list.Items = append(list.Items, c.convertSelectElement(elem)) } return list } -func stripOutputQualifier(node ast.Node) { - ref, ok := node.(*ast.ColumnRef) - if !ok || ref.Fields == nil || len(ref.Fields.Items) < 2 { - return - } - if first, ok := ref.Fields.Items[0].(*ast.String); ok { - switch first.Str { - case "inserted", "deleted": - ref.Fields.Items = ref.Fields.Items[1:] - } - } -} - func (c *cc) convertInsertStatement(n *tsql.InsertStatement) ast.Node { if n.InsertSpecification == nil { return todo(n) @@ -805,7 +1382,8 @@ func (c *cc) convertInsertStatement(n *tsql.InsertStatement) ast.Node { } stmt := &ast.InsertStmt{ - Relation: c.parseRangeVar(target.SchemaObject), + Relation: c.parseRangeVar(target.SchemaObject), + WithClause: c.convertWithClause(n.WithCtesAndXmlNamespaces), } if len(spec.Columns) > 0 { @@ -1074,6 +1652,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 +1702,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 +1799,345 @@ 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, + } +} + +// convertCreateFunctionStatement records a function. A scalar function's +// result SQL Server reports nullable whatever its arguments are. A +// table-valued function returns rows of table(col type, ...), the columns +// it declares; an inline one's are those its query selects, which the +// schema works out from the query, passed as the "query" option. +func (c *cc) convertCreateFunctionStatement(n *tsql.CreateFunctionStatement) ast.Node { + if n.Name == nil || n.Name.BaseIdentifier == nil { + return todo(n) + } + var returns *ast.TypeName + var options *ast.List + switch ret := n.ReturnType.(type) { + case *tsql.ScalarFunctionReturnType: + if ret.DataType == nil { + return todo(n) + } + returns = nullableTypeName(dataTypeName(ret.DataType)) + case *tsql.TableValuedFunctionReturnType: + if ret.DeclareTableVariableBody == nil || ret.DeclareTableVariableBody.Definition == nil { + return todo(n) + } + var cols []string + for _, col := range ret.DeclareTableVariableBody.Definition.ColumnDefinitions { + def := c.convertColumnDefinition(col, nil) + t := def.TypeName + if !def.IsNotNull { + t = nullableTypeName(t) + } + spelled := core.TypeExprOfTypeName(t) + if spelled == nil { + return todo(n) + } + cols = append(cols, def.Colname+" "+typeSpelling(t, spelled)) + } + returns = &ast.TypeName{Spelling: "table(" + strings.Join(cols, ", ") + ")", Setof: true} + case *tsql.SelectFunctionReturnType: + if ret.SelectStatement == nil { + return todo(n) + } + returns = &ast.TypeName{Name: "table", Setof: true} + query := "query" + options = &ast.List{Items: []ast.Node{&ast.DefElem{Defname: &query, Arg: c.convertSelectStatement(ret.SelectStatement)}}} + default: + return todo(n) + } + tn := parseTableName(n.Name) + params := &ast.List{} + for _, p := range n.Parameters { + if p.VariableName == nil || p.DataType == nil { + continue + } + name := strings.TrimPrefix(p.VariableName.Value, "@") + param := &ast.FuncParam{Name: &name, Type: dataTypeName(p.DataType)} + if p.Value != nil { + param.DefExpr = c.convertScalarExpression(p.Value) + } + params.Items = append(params.Items, param) + } + return &ast.CreateFunctionStmt{ + Func: &ast.FuncName{Schema: tn.Schema, Name: tn.Name}, + Params: params, + ReturnType: returns, + Options: options, + } +} + +// 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, + } +} + +// numericLiteral is a number written with a decimal point, or too large +// for an int, which SQL Server types as the decimal holding its digits: +// 1.50 is a decimal(3,2), 2147483648 a decimal(10,0). +func (c *cc) numericLiteral(value string, n tsql.Node) ast.Node { + whole, frac, _ := strings.Cut(value, ".") + whole = strings.TrimLeft(whole, "0") + scale := int64(len(frac)) + precision := max(int64(len(whole))+scale, 1) + return &ast.TypeCast{ + Arg: &ast.A_Const{Val: &ast.Float{Str: value}, Location: c.loc(n)}, + TypeName: &ast.TypeName{Name: "decimal", Typmods: appendTypmod(appendTypmod(nil, + &ast.A_Const{Val: &ast.Integer{Ival: precision}}), &ast.A_Const{Val: &ast.Integer{Ival: scale}})}, + Location: c.loc(n), + } +} + +// namedCall is a call of name with args, for a function the parser gives a +// node of its own, as LEFT and RIGHT, which are keywords too. +func (c *cc) namedCall(name string, args []tsql.ScalarExpression, n tsql.Node) *ast.FuncCall { + call := &ast.FuncCall{ + Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: name}}}, + Args: &ast.List{}, + Location: c.loc(n), + } + for _, arg := range args { + call.Args.Items = append(call.Args.Items, c.convertScalarExpression(arg)) + } + return call +} + +// typeSpelling spells a type so that it parses back as the same type, which +// for a nullable one is the Nullable(T) it was spelled as. +func typeSpelling(tn *ast.TypeName, t *core.TypeExpr) string { + if tn.Spelling != "" { + return tn.Spelling + } + return t.String() +} + +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/dialect/dialect.json b/internal/engine/mssql/dialect/dialect.json index 30ea408744..a038bad0ec 100644 --- a/internal/engine/mssql/dialect/dialect.json +++ b/internal/engine/mssql/dialect/dialect.json @@ -8,6 +8,30 @@ "bool": "bit" }, "bool": "bit", + "limit": "bigint", + "outer_join_nullable": true, + "returning_aliases": ["inserted", "deleted"], + "set_operations": { + "precedence": [ + "sql_variant", "xml", "datetimeoffset", "datetime2", "datetime", + "smalldatetime", "date", "time", "float", "real", "decimal", "money", + "smallmoney", "bigint", "int", "smallint", "tinyint", "bit", "ntext", + "text", "image", "rowversion", "uniqueidentifier", "nvarchar", "nchar", + "varchar", "char", "varbinary", "binary" + ], + "varying": {"char": "varchar", "nchar": "nvarchar", "binary": "varbinary"}, + "decimal": "decimal", + "decimal_max_precision": 38, + "as_decimal": { + "bit": [1, 0], + "tinyint": [3, 0], + "smallint": [5, 0], + "int": [10, 0], + "bigint": [19, 0], + "money": [19, 4], + "smallmoney": [10, 4] + } + }, "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="], "comparison_categories": "NBSD", "arithmetic": ["+", "-", "*", "/", "%"], diff --git a/internal/engine/mssql/dialect/functions.jsonl b/internal/engine/mssql/dialect/functions.jsonl index e0cd45408c..9396dad946 100644 --- a/internal/engine/mssql/dialect/functions.jsonl +++ b/internal/engine/mssql/dialect/functions.jsonl @@ -50,6 +50,28 @@ {"name": "max", "kind": "a", "args": [{"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} {"name": "max", "kind": "a", "args": [{"type": "char"}], "returns": "char", "nullable": true} {"name": "max", "kind": "a", "args": [{"type": "nchar"}], "returns": "nchar", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "varchar(8000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "char"}, {"type": "varchar"}], "returns": "varchar(8000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "nvarchar"}, {"type": "varchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "string_agg", "kind": "a", "args": [{"type": "nchar"}, {"type": "varchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "stdev", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "stdevp", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "var", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "varp", "kind": "a", "args": [{"type": "any"}], "returns": "float", "nullable": true} +{"name": "row_number", "kind": "w", "returns": "bigint"} +{"name": "rank", "kind": "w", "returns": "bigint"} +{"name": "dense_rank", "kind": "w", "returns": "bigint"} +{"name": "ntile", "kind": "w", "args": [{"type": "bigint"}], "returns": "bigint"} +{"name": "percent_rank", "kind": "w", "returns": "float", "nullable": true} +{"name": "cume_dist", "kind": "w", "returns": "float", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}], "returns": "$1", "nullable": true} +{"name": "lag", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}], "returns": "$1", "nullable": true} +{"name": "lead", "kind": "w", "args": [{"type": "any"}, {"type": "bigint"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "first_value", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} +{"name": "last_value", "kind": "w", "args": [{"type": "any"}], "returns": "$1", "nullable": true} {"name": "getdate", "returns": "datetime"} {"name": "getutcdate", "returns": "datetime"} {"name": "sysdatetime", "returns": "datetime2"} @@ -74,3 +96,327 @@ {"name": "rtrim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} {"name": "trim", "args": [{"type": "varchar"}], "returns": "varchar"} {"name": "trim", "args": [{"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "nullif", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "concat", "args": [{"type": "any"}, {"type": "any"}], "returns": "varchar"} +{"name": "concat", "args": [{"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "any"}, {"type": "any"}], "returns": "varchar"} +{"name": "concat_ws", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar"} +{"name": "concat_ws", "args": [{"type": "any"}, {"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "substring", "args": [{"type": "varchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "substring", "args": [{"type": "char"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varchar", "nullable": true} +{"name": "substring", "args": [{"type": "nvarchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "substring", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "nvarchar", "nullable": true} +{"name": "substring", "args": [{"type": "varbinary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} +{"name": "substring", "args": [{"type": "binary"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "varbinary", "nullable": true} +{"name": "left", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "left", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "left", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "right", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "right", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "replace", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "replace", "args": [{"type": "char"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "replace", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "replace", "args": [{"type": "nchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "translate", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "varchar(8000)", "nullable": true} +{"name": "translate", "args": [{"type": "nvarchar"}, {"type": "any"}, {"type": "any"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "replicate", "args": [{"type": "varchar"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "char"}, {"type": "int"}], "returns": "varchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nvarchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "replicate", "args": [{"type": "nchar"}, {"type": "int"}], "returns": "nvarchar", "nullable": true} +{"name": "reverse", "args": [{"type": "varchar"}], "returns": "$1", "nullable": true} +{"name": "reverse", "args": [{"type": "char"}], "returns": "varchar", "nullable": true} +{"name": "reverse", "args": [{"type": "nvarchar"}], "returns": "$1", "nullable": true} +{"name": "reverse", "args": [{"type": "nchar"}], "returns": "nvarchar", "nullable": true} +{"name": "stuff", "args": [{"type": "varchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "varchar", "nullable": true} +{"name": "stuff", "args": [{"type": "char"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "varchar", "nullable": true} +{"name": "stuff", "args": [{"type": "nvarchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "nvarchar", "nullable": true} +{"name": "stuff", "args": [{"type": "nchar"}, {"type": "bigint"}, {"type": "bigint"}, {"type": "any"}], "returns": "nvarchar", "nullable": true} +{"name": "space", "args": [{"type": "int"}], "returns": "varchar(8000)", "nullable": true} +{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "charindex", "args": [{"type": "any"}, {"type": "any"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "patindex", "args": [{"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "ascii", "args": [{"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "unicode", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "format", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "format", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "quotename", "args": [{"type": "nvarchar"}], "returns": "nvarchar(258)", "nullable": true} +{"name": "quotename", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar(258)", "nullable": true} +{"name": "str", "args": [{"type": "float"}], "returns": "varchar(10)", "nullable": true} +{"name": "str", "args": [{"type": "float"}, {"type": "int"}], "returns": "varchar($2)", "nullable": true} +{"name": "str", "args": [{"type": "float"}, {"type": "int"}, {"type": "int"}], "returns": "varchar($2)", "nullable": true} +{"name": "abs", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "abs", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "abs", "args": [{"type": "decimal"}], "returns": "$1", "nullable": true} +{"name": "abs", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "abs", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "abs", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "abs", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "sign", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "sign", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "sign", "args": [{"type": "decimal"}], "returns": "$1", "nullable": true} +{"name": "sign", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "sign", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "sign", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "sign", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "ceiling", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "ceiling", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "ceiling", "args": [{"type": "decimal"}], "returns": "decimal", "nullable": true} +{"name": "ceiling", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "ceiling", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "ceiling", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "ceiling", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "floor", "args": [{"type": "bigint"}], "returns": "bigint", "nullable": true} +{"name": "floor", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "smallint"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "tinyint"}], "returns": "int", "nullable": true} +{"name": "floor", "args": [{"type": "decimal"}], "returns": "decimal", "nullable": true} +{"name": "floor", "args": [{"type": "money"}], "returns": "money", "nullable": true} +{"name": "floor", "args": [{"type": "smallmoney"}], "returns": "money", "nullable": true} +{"name": "floor", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "floor", "args": [{"type": "real"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "bigint"}, {"type": "int"}], "returns": "bigint", "nullable": true} +{"name": "round", "args": [{"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "smallint"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "tinyint"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "decimal"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "round", "args": [{"type": "money"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "smallmoney"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "float"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "real"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "bigint"}, {"type": "int"}, {"type": "int"}], "returns": "bigint", "nullable": true} +{"name": "round", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "smallint"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "tinyint"}, {"type": "int"}, {"type": "int"}], "returns": "int", "nullable": true} +{"name": "round", "args": [{"type": "decimal"}, {"type": "int"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "round", "args": [{"type": "money"}, {"type": "int"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "smallmoney"}, {"type": "int"}, {"type": "int"}], "returns": "money", "nullable": true} +{"name": "round", "args": [{"type": "float"}, {"type": "int"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "round", "args": [{"type": "real"}, {"type": "int"}, {"type": "int"}], "returns": "float", "nullable": true} +{"name": "power", "args": [{"type": "bigint"}, {"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "power", "args": [{"type": "int"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "smallint"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "tinyint"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "power", "args": [{"type": "decimal"}, {"type": "any"}], "returns": "decimal", "nullable": true} +{"name": "power", "args": [{"type": "money"}, {"type": "any"}], "returns": "money", "nullable": true} +{"name": "power", "args": [{"type": "smallmoney"}, {"type": "any"}], "returns": "money", "nullable": true} +{"name": "power", "args": [{"type": "float"}, {"type": "any"}], "returns": "float", "nullable": true} +{"name": "power", "args": [{"type": "real"}, {"type": "any"}], "returns": "float", "nullable": true} +{"name": "sqrt", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "square", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "exp", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "log", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "log", "args": [{"type": "float"}, {"type": "float"}], "returns": "float", "nullable": true} +{"name": "log10", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "pi", "returns": "float"} +{"name": "rand", "returns": "float", "nullable": true} +{"name": "rand", "args": [{"type": "int"}], "returns": "float", "nullable": true} +{"name": "year", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "month", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "day", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "isdate", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "eomonth", "args": [{"type": "any"}], "returns": "date", "nullable": true} +{"name": "eomonth", "args": [{"type": "any"}, {"type": "int"}], "returns": "date", "nullable": true} +{"name": "datefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "date", "nullable": true} +{"name": "datetimefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetime", "nullable": true} +{"name": "datetime2fromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetime2($8)", "nullable": true} +{"name": "datetimeoffsetfromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "datetimeoffset($10)", "nullable": true} +{"name": "timefromparts", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "time($5)", "nullable": true} +{"name": "switchoffset", "args": [{"type": "datetimeoffset"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "todatetimeoffset", "args": [{"type": "any"}, {"type": "any"}], "returns": "datetimeoffset", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "varchar"}], "returns": "datetime", "nullable": true} +{"name": "dateadd", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "nvarchar"}], "returns": "datetime", "nullable": true} +{"name": "datediff", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "datediff_big", "args": [{"type": "varchar"}, {"type": "any"}, {"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "datepart", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "int", "nullable": true} +{"name": "datename", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "nvarchar(30)", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "$2", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "datetime2(7)", "nullable": true} +{"name": "datetrunc", "args": [{"type": "varchar"}, {"type": "nvarchar"}], "returns": "datetime2(7)", "nullable": true} +{"name": "isjson", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "isjson", "args": [{"type": "any"}, {"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "json_value", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "json_query", "args": [{"type": "any"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_query", "args": [{"type": "any"}, {"type": "nvarchar"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_modify", "args": [{"type": "any"}, {"type": "nvarchar"}, {"type": "any"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "json_object", "returns": "nvarchar(max)", "nullable": true} +{"name": "json_array", "returns": "nvarchar(max)", "nullable": true} +{"name": "hashbytes", "args": [{"type": "varchar"}, {"type": "any"}], "returns": "varbinary(8000)", "nullable": true} +{"name": "checksum", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "binary_checksum", "args": [{"type": "any"}], "returns": "int", "nullable": true} +{"name": "openjson", "args": [{"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} +{"name": "openjson", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar", "nullable": true} +{"name": "string_split", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}, {"type": "int"}], "returns": "$1"} +{"name": "string_split", "args": [{"type": "varchar"}, {"type": "varchar"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "int"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "bigint"}, {"type": "bigint"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "decimal"}, {"type": "decimal"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "int"}, {"type": "int"}, {"type": "int"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "bigint"}, {"type": "bigint"}, {"type": "bigint"}], "returns": "$1"} +{"name": "generate_series", "args": [{"type": "decimal"}, {"type": "decimal"}, {"type": "decimal"}], "returns": "$1"} +{"name": "at time zone", "args": [{"type": "datetimeoffset"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(7)", "nullable": true} +{"name": "at time zone", "args": [{"type": "datetime2"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(7)", "nullable": true} +{"name": "at time zone", "args": [{"type": "datetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(3)", "nullable": true} +{"name": "at time zone", "args": [{"type": "smalldatetime"}, {"type": "nvarchar(4000)"}], "returns": "datetimeoffset(0)", "nullable": true} +{"name": "parse", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "nvarchar"} +{"name": "@@rowcount", "returns": "int"} +{"name": "@@identity", "returns": "numeric(38, 0)", "nullable": true} +{"name": "@@spid", "returns": "smallint"} +{"name": "@@version", "returns": "nvarchar(300)", "nullable": true} +{"name": "@@trancount", "returns": "int"} +{"name": "@@error", "returns": "int"} +{"name": "@@fetch_status", "returns": "int"} +{"name": "@@servername", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@servicename", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@language", "returns": "nvarchar(128)", "nullable": true} +{"name": "@@datefirst", "returns": "tinyint", "nullable": true} +{"name": "@@max_precision", "returns": "tinyint"} +{"name": "@@nestlevel", "returns": "int"} +{"name": "@@procid", "returns": "int"} +{"name": "@@dbts", "returns": "varbinary(8)"} +{"name": "@@lock_timeout", "returns": "int"} +{"name": "@@options", "returns": "int"} +{"name": "@@textsize", "returns": "int"} +{"name": "@@cursor_rows", "returns": "int"} +{"name": "contains", "args": [{"type": "nvarchar(4000)"}], "returns": "bit"} +{"name": "contains", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} +{"name": "freetext", "args": [{"type": "nvarchar(4000)"}], "returns": "bit"} +{"name": "freetext", "args": [{"type": "nvarchar(4000)"}, {"type": "any"}], "returns": "bit"} +{"name": ".exist", "args": [{"type": "xml"}, {"type": "nvarchar(4000)"}], "returns": "bit", "nullable": true} +{"name": ".getlevel", "args": [{"type": "hierarchyid"}], "returns": "smallint", "nullable": true} +{"name": ".tostring", "args": [{"type": "hierarchyid"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".getancestor", "args": [{"type": "hierarchyid"}, {"type": "int"}], "returns": "hierarchyid", "nullable": true} +{"name": ".getdescendant", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "hierarchyid", "nullable": true} +{"name": ".isdescendantof", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "bit", "nullable": true} +{"name": ".getreparentedvalue", "args": [{"type": "hierarchyid"}, {"type": "hierarchyid"}, {"type": "hierarchyid"}], "returns": "hierarchyid", "nullable": true} +{"name": "hierarchyid::getroot", "args": [], "returns": "hierarchyid", "nullable": true} +{"name": "hierarchyid::parse", "args": [{"type": "nvarchar(4000)"}], "returns": "hierarchyid", "nullable": true} +{"name": ".tostring", "args": [{"type": "geography"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stastext", "args": [{"type": "geography"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stasbinary", "args": [{"type": "geography"}], "returns": "varbinary(max)", "nullable": true} +{"name": ".starea", "args": [{"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stlength", "args": [{"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stdistance", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "float", "nullable": true} +{"name": ".stintersects", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stcontains", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stwithin", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stequals", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stisvalid", "args": [{"type": "geography"}], "returns": "bit", "nullable": true} +{"name": ".stbuffer", "args": [{"type": "geography"}, {"type": "float"}], "returns": "geography", "nullable": true} +{"name": ".stunion", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "geography", "nullable": true} +{"name": ".stintersection", "args": [{"type": "geography"}, {"type": "geography"}], "returns": "geography", "nullable": true} +{"name": ".stnumpoints", "args": [{"type": "geography"}], "returns": "int", "nullable": true} +{"name": ".stdimension", "args": [{"type": "geography"}], "returns": "int", "nullable": true} +{"name": ".stgeometrytype", "args": [{"type": "geography"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".stpointn", "args": [{"type": "geography"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "geography::stgeomfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "geography::stpointfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": ".tostring", "args": [{"type": "geometry"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stastext", "args": [{"type": "geometry"}], "returns": "nvarchar(max)", "nullable": true} +{"name": ".stasbinary", "args": [{"type": "geometry"}], "returns": "varbinary(max)", "nullable": true} +{"name": ".starea", "args": [{"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stlength", "args": [{"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stdistance", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "float", "nullable": true} +{"name": ".stintersects", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stcontains", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stwithin", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stequals", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stisvalid", "args": [{"type": "geometry"}], "returns": "bit", "nullable": true} +{"name": ".stbuffer", "args": [{"type": "geometry"}, {"type": "float"}], "returns": "geometry", "nullable": true} +{"name": ".stunion", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "geometry", "nullable": true} +{"name": ".stintersection", "args": [{"type": "geometry"}, {"type": "geometry"}], "returns": "geometry", "nullable": true} +{"name": ".stnumpoints", "args": [{"type": "geometry"}], "returns": "int", "nullable": true} +{"name": ".stdimension", "args": [{"type": "geometry"}], "returns": "int", "nullable": true} +{"name": ".stgeometrytype", "args": [{"type": "geometry"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": ".stpointn", "args": [{"type": "geometry"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geometry::stgeomfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geometry::stpointfromtext", "args": [{"type": "nvarchar(max)"}, {"type": "int"}], "returns": "geometry", "nullable": true} +{"name": "geography::point", "args": [{"type": "float"}, {"type": "float"}, {"type": "int"}], "returns": "geography", "nullable": true} +{"name": "grouping", "kind": "a", "args": [{"type": "any"}], "returns": "tinyint", "never_null": true} +{"name": "grouping_id", "kind": "a", "args": [{"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "never_null": true} +{"name": "approx_count_distinct", "kind": "a", "args": [{"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "checksum_agg", "kind": "a", "args": [{"type": "int"}], "returns": "int", "nullable": true} +{"name": "percentile_cont", "kind": "w", "args": [{"type": "float"}], "returns": "float", "nullable": true} +{"name": "ident_current", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "ident_seed", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "ident_incr", "args": [{"type": "nvarchar"}], "returns": "decimal(38,0)", "nullable": true} +{"name": "rowcount_big", "returns": "bigint", "never_null": true} +{"name": "db_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_sname", "returns": "nvarchar(128)", "nullable": true} +{"name": "schema_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "user_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "db_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_sname", "args": [{"type": "varbinary"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "schema_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "user_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "host_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "app_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "suser_name", "returns": "nvarchar(128)", "nullable": true} +{"name": "current_timezone", "returns": "nvarchar(128)", "nullable": true} +{"name": "current_timezone_id", "returns": "nvarchar(128)", "nullable": true} +{"name": "error_procedure", "returns": "nvarchar(128)", "nullable": true} +{"name": "original_login", "returns": "nvarchar(4000)", "nullable": true} +{"name": "object_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "object_id", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "object_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_schema_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_schema_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "object_definition", "args": [{"type": "int"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "db_id", "returns": "smallint", "nullable": true} +{"name": "db_id", "args": [{"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "user_id", "returns": "smallint", "nullable": true} +{"name": "user_id", "args": [{"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "suser_id", "returns": "int", "nullable": true} +{"name": "suser_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "schema_id", "returns": "int", "nullable": true} +{"name": "schema_id", "args": [{"type": "nvarchar"}], "returns": "int", "nullable": true} +{"name": "suser_sid", "returns": "varbinary(85)", "nullable": true} +{"name": "col_length", "args": [{"type": "nvarchar"}, {"type": "nvarchar"}], "returns": "smallint", "nullable": true} +{"name": "col_name", "args": [{"type": "int"}, {"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "type_name", "args": [{"type": "int"}], "returns": "nvarchar(128)", "nullable": true} +{"name": "error_number", "returns": "int", "nullable": true} +{"name": "error_severity", "returns": "int", "nullable": true} +{"name": "error_state", "returns": "int", "nullable": true} +{"name": "error_line", "returns": "int", "nullable": true} +{"name": "error_message", "returns": "nvarchar(4000)", "nullable": true} +{"name": "xact_state", "returns": "smallint", "nullable": true} +{"name": "session_context", "args": [{"type": "nvarchar"}], "returns": "sql_variant", "nullable": true} +{"name": "context_info", "returns": "varbinary(128)", "nullable": true} +{"name": "sql_variant_property", "args": [{"type": "any"}, {"type": "varchar"}], "returns": "sql_variant", "nullable": true} +{"name": "string_escape", "args": [{"type": "nvarchar"}, {"type": "varchar"}], "returns": "nvarchar(max)", "nullable": true} +{"name": "soundex", "args": [{"type": "varchar"}], "returns": "varchar(5)", "nullable": true} +{"name": "difference", "args": [{"type": "varchar"}, {"type": "varchar"}], "returns": "int", "nullable": true} +{"name": "formatmessage", "args": [{"type": "any"}, {"type": "any", "mode": "v"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "ltrim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "rtrim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$1", "nullable": true} +{"name": "compress", "args": [{"type": "any"}], "returns": "varbinary(max)", "nullable": true} +{"name": "decompress", "args": [{"type": "any"}], "returns": "varbinary(max)", "nullable": true} +{"name": "bit_count", "args": [{"type": "any"}], "returns": "bigint", "nullable": true} +{"name": "left_shift", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "right_shift", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "get_bit", "args": [{"type": "any"}, {"type": "int"}], "returns": "bit", "nullable": true} +{"name": "set_bit", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "set_bit", "args": [{"type": "any"}, {"type": "int"}, {"type": "int"}], "returns": "$1", "nullable": true} +{"name": "date_bucket", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "date_bucket", "args": [{"type": "varchar"}, {"type": "int"}, {"type": "any"}, {"type": "any"}], "returns": "$3", "nullable": true} +{"name": "regexp_replace", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "nvarchar(4000)", "nullable": true} +{"name": "regexp_substr", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "$1", "nullable": true} +{"name": "regexp_instr", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} +{"name": "regexp_count", "args": [{"type": "any"}, {"type": "any"}, {"type": "any", "mode": "v"}], "returns": "int", "nullable": true} +{"name": "vector_distance", "args": [{"type": "varchar"}, {"type": "vector"}, {"type": "vector"}], "returns": "float", "nullable": true} +{"name": "trim", "args": [{"type": "any"}, {"type": "any"}], "returns": "$2"} +{"name": "convert style", "args": [{"type": "any"}, {"type": "int"}], "returns": "$1", "nullable": true} diff --git a/internal/engine/mssql/dialect/operators.jsonl b/internal/engine/mssql/dialect/operators.jsonl new file mode 100644 index 0000000000..8d241329af --- /dev/null +++ b/internal/engine/mssql/dialect/operators.jsonl @@ -0,0 +1,432 @@ +{"name": "+", "left": "float", "right": "real", "result": "float"} +{"name": "+", "left": "float", "right": "decimal", "result": "float"} +{"name": "+", "left": "float", "right": "money", "result": "float"} +{"name": "+", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "+", "left": "float", "right": "bigint", "result": "float"} +{"name": "+", "left": "float", "right": "int", "result": "float"} +{"name": "+", "left": "float", "right": "smallint", "result": "float"} +{"name": "+", "left": "float", "right": "tinyint", "result": "float"} +{"name": "+", "left": "float", "right": "bit", "result": "float"} +{"name": "+", "left": "real", "right": "float", "result": "float"} +{"name": "+", "left": "real", "right": "decimal", "result": "real"} +{"name": "+", "left": "real", "right": "money", "result": "real"} +{"name": "+", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "+", "left": "real", "right": "bigint", "result": "real"} +{"name": "+", "left": "real", "right": "int", "result": "real"} +{"name": "+", "left": "real", "right": "smallint", "result": "real"} +{"name": "+", "left": "real", "right": "tinyint", "result": "real"} +{"name": "+", "left": "real", "right": "bit", "result": "real"} +{"name": "+", "left": "decimal", "right": "float", "result": "float"} +{"name": "+", "left": "decimal", "right": "real", "result": "real"} +{"name": "+", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "+", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "+", "left": "money", "right": "float", "result": "float"} +{"name": "+", "left": "money", "right": "real", "result": "real"} +{"name": "+", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "+", "left": "money", "right": "bigint", "result": "money"} +{"name": "+", "left": "money", "right": "int", "result": "money"} +{"name": "+", "left": "money", "right": "smallint", "result": "money"} +{"name": "+", "left": "money", "right": "tinyint", "result": "money"} +{"name": "+", "left": "money", "right": "bit", "result": "money"} +{"name": "+", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "+", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "+", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "+", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "+", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "+", "left": "bigint", "right": "float", "result": "float"} +{"name": "+", "left": "bigint", "right": "real", "result": "real"} +{"name": "+", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "bigint", "right": "money", "result": "money"} +{"name": "+", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "+", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "+", "left": "int", "right": "float", "result": "float"} +{"name": "+", "left": "int", "right": "real", "result": "real"} +{"name": "+", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "int", "right": "money", "result": "money"} +{"name": "+", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "int", "right": "smallint", "result": "int"} +{"name": "+", "left": "int", "right": "tinyint", "result": "int"} +{"name": "+", "left": "int", "right": "bit", "result": "int"} +{"name": "+", "left": "smallint", "right": "float", "result": "float"} +{"name": "+", "left": "smallint", "right": "real", "result": "real"} +{"name": "+", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "smallint", "right": "money", "result": "money"} +{"name": "+", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "smallint", "right": "int", "result": "int"} +{"name": "+", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "+", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "+", "left": "tinyint", "right": "float", "result": "float"} +{"name": "+", "left": "tinyint", "right": "real", "result": "real"} +{"name": "+", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "tinyint", "right": "money", "result": "money"} +{"name": "+", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "tinyint", "right": "int", "result": "int"} +{"name": "+", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "+", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "+", "left": "bit", "right": "float", "result": "float"} +{"name": "+", "left": "bit", "right": "real", "result": "real"} +{"name": "+", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "+", "left": "bit", "right": "money", "result": "money"} +{"name": "+", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "+", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "+", "left": "bit", "right": "int", "result": "int"} +{"name": "+", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "+", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "-", "left": "float", "right": "real", "result": "float"} +{"name": "-", "left": "float", "right": "decimal", "result": "float"} +{"name": "-", "left": "float", "right": "money", "result": "float"} +{"name": "-", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "-", "left": "float", "right": "bigint", "result": "float"} +{"name": "-", "left": "float", "right": "int", "result": "float"} +{"name": "-", "left": "float", "right": "smallint", "result": "float"} +{"name": "-", "left": "float", "right": "tinyint", "result": "float"} +{"name": "-", "left": "float", "right": "bit", "result": "float"} +{"name": "-", "left": "real", "right": "float", "result": "float"} +{"name": "-", "left": "real", "right": "decimal", "result": "real"} +{"name": "-", "left": "real", "right": "money", "result": "real"} +{"name": "-", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "-", "left": "real", "right": "bigint", "result": "real"} +{"name": "-", "left": "real", "right": "int", "result": "real"} +{"name": "-", "left": "real", "right": "smallint", "result": "real"} +{"name": "-", "left": "real", "right": "tinyint", "result": "real"} +{"name": "-", "left": "real", "right": "bit", "result": "real"} +{"name": "-", "left": "decimal", "right": "float", "result": "float"} +{"name": "-", "left": "decimal", "right": "real", "result": "real"} +{"name": "-", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "-", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "-", "left": "money", "right": "float", "result": "float"} +{"name": "-", "left": "money", "right": "real", "result": "real"} +{"name": "-", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "-", "left": "money", "right": "bigint", "result": "money"} +{"name": "-", "left": "money", "right": "int", "result": "money"} +{"name": "-", "left": "money", "right": "smallint", "result": "money"} +{"name": "-", "left": "money", "right": "tinyint", "result": "money"} +{"name": "-", "left": "money", "right": "bit", "result": "money"} +{"name": "-", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "-", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "-", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "-", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "-", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "-", "left": "bigint", "right": "float", "result": "float"} +{"name": "-", "left": "bigint", "right": "real", "result": "real"} +{"name": "-", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "bigint", "right": "money", "result": "money"} +{"name": "-", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "-", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "-", "left": "int", "right": "float", "result": "float"} +{"name": "-", "left": "int", "right": "real", "result": "real"} +{"name": "-", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "int", "right": "money", "result": "money"} +{"name": "-", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "int", "right": "smallint", "result": "int"} +{"name": "-", "left": "int", "right": "tinyint", "result": "int"} +{"name": "-", "left": "int", "right": "bit", "result": "int"} +{"name": "-", "left": "smallint", "right": "float", "result": "float"} +{"name": "-", "left": "smallint", "right": "real", "result": "real"} +{"name": "-", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "smallint", "right": "money", "result": "money"} +{"name": "-", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "smallint", "right": "int", "result": "int"} +{"name": "-", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "-", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "-", "left": "tinyint", "right": "float", "result": "float"} +{"name": "-", "left": "tinyint", "right": "real", "result": "real"} +{"name": "-", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "tinyint", "right": "money", "result": "money"} +{"name": "-", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "tinyint", "right": "int", "result": "int"} +{"name": "-", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "-", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "-", "left": "bit", "right": "float", "result": "float"} +{"name": "-", "left": "bit", "right": "real", "result": "real"} +{"name": "-", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "-", "left": "bit", "right": "money", "result": "money"} +{"name": "-", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "-", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "-", "left": "bit", "right": "int", "result": "int"} +{"name": "-", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "-", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "*", "left": "float", "right": "real", "result": "float"} +{"name": "*", "left": "float", "right": "decimal", "result": "float"} +{"name": "*", "left": "float", "right": "money", "result": "float"} +{"name": "*", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "*", "left": "float", "right": "bigint", "result": "float"} +{"name": "*", "left": "float", "right": "int", "result": "float"} +{"name": "*", "left": "float", "right": "smallint", "result": "float"} +{"name": "*", "left": "float", "right": "tinyint", "result": "float"} +{"name": "*", "left": "float", "right": "bit", "result": "float"} +{"name": "*", "left": "real", "right": "float", "result": "float"} +{"name": "*", "left": "real", "right": "decimal", "result": "real"} +{"name": "*", "left": "real", "right": "money", "result": "real"} +{"name": "*", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "*", "left": "real", "right": "bigint", "result": "real"} +{"name": "*", "left": "real", "right": "int", "result": "real"} +{"name": "*", "left": "real", "right": "smallint", "result": "real"} +{"name": "*", "left": "real", "right": "tinyint", "result": "real"} +{"name": "*", "left": "real", "right": "bit", "result": "real"} +{"name": "*", "left": "decimal", "right": "float", "result": "float"} +{"name": "*", "left": "decimal", "right": "real", "result": "real"} +{"name": "*", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "*", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "*", "left": "money", "right": "float", "result": "float"} +{"name": "*", "left": "money", "right": "real", "result": "real"} +{"name": "*", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "*", "left": "money", "right": "bigint", "result": "money"} +{"name": "*", "left": "money", "right": "int", "result": "money"} +{"name": "*", "left": "money", "right": "smallint", "result": "money"} +{"name": "*", "left": "money", "right": "tinyint", "result": "money"} +{"name": "*", "left": "money", "right": "bit", "result": "money"} +{"name": "*", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "*", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "*", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "*", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "*", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "*", "left": "bigint", "right": "float", "result": "float"} +{"name": "*", "left": "bigint", "right": "real", "result": "real"} +{"name": "*", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "bigint", "right": "money", "result": "money"} +{"name": "*", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "*", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "*", "left": "int", "right": "float", "result": "float"} +{"name": "*", "left": "int", "right": "real", "result": "real"} +{"name": "*", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "int", "right": "money", "result": "money"} +{"name": "*", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "int", "right": "smallint", "result": "int"} +{"name": "*", "left": "int", "right": "tinyint", "result": "int"} +{"name": "*", "left": "int", "right": "bit", "result": "int"} +{"name": "*", "left": "smallint", "right": "float", "result": "float"} +{"name": "*", "left": "smallint", "right": "real", "result": "real"} +{"name": "*", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "smallint", "right": "money", "result": "money"} +{"name": "*", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "smallint", "right": "int", "result": "int"} +{"name": "*", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "*", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "*", "left": "tinyint", "right": "float", "result": "float"} +{"name": "*", "left": "tinyint", "right": "real", "result": "real"} +{"name": "*", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "tinyint", "right": "money", "result": "money"} +{"name": "*", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "tinyint", "right": "int", "result": "int"} +{"name": "*", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "*", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "*", "left": "bit", "right": "float", "result": "float"} +{"name": "*", "left": "bit", "right": "real", "result": "real"} +{"name": "*", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "*", "left": "bit", "right": "money", "result": "money"} +{"name": "*", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "*", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "*", "left": "bit", "right": "int", "result": "int"} +{"name": "*", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "*", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "/", "left": "float", "right": "real", "result": "float"} +{"name": "/", "left": "float", "right": "decimal", "result": "float"} +{"name": "/", "left": "float", "right": "money", "result": "float"} +{"name": "/", "left": "float", "right": "smallmoney", "result": "float"} +{"name": "/", "left": "float", "right": "bigint", "result": "float"} +{"name": "/", "left": "float", "right": "int", "result": "float"} +{"name": "/", "left": "float", "right": "smallint", "result": "float"} +{"name": "/", "left": "float", "right": "tinyint", "result": "float"} +{"name": "/", "left": "float", "right": "bit", "result": "float"} +{"name": "/", "left": "real", "right": "float", "result": "float"} +{"name": "/", "left": "real", "right": "decimal", "result": "real"} +{"name": "/", "left": "real", "right": "money", "result": "real"} +{"name": "/", "left": "real", "right": "smallmoney", "result": "real"} +{"name": "/", "left": "real", "right": "bigint", "result": "real"} +{"name": "/", "left": "real", "right": "int", "result": "real"} +{"name": "/", "left": "real", "right": "smallint", "result": "real"} +{"name": "/", "left": "real", "right": "tinyint", "result": "real"} +{"name": "/", "left": "real", "right": "bit", "result": "real"} +{"name": "/", "left": "decimal", "right": "float", "result": "float"} +{"name": "/", "left": "decimal", "right": "real", "result": "real"} +{"name": "/", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "/", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "/", "left": "money", "right": "float", "result": "float"} +{"name": "/", "left": "money", "right": "real", "result": "real"} +{"name": "/", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "/", "left": "money", "right": "bigint", "result": "money"} +{"name": "/", "left": "money", "right": "int", "result": "money"} +{"name": "/", "left": "money", "right": "smallint", "result": "money"} +{"name": "/", "left": "money", "right": "tinyint", "result": "money"} +{"name": "/", "left": "money", "right": "bit", "result": "money"} +{"name": "/", "left": "smallmoney", "right": "float", "result": "float"} +{"name": "/", "left": "smallmoney", "right": "real", "result": "real"} +{"name": "/", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "/", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "/", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "/", "left": "bigint", "right": "float", "result": "float"} +{"name": "/", "left": "bigint", "right": "real", "result": "real"} +{"name": "/", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "bigint", "right": "money", "result": "money"} +{"name": "/", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "/", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "/", "left": "int", "right": "float", "result": "float"} +{"name": "/", "left": "int", "right": "real", "result": "real"} +{"name": "/", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "int", "right": "money", "result": "money"} +{"name": "/", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "int", "right": "smallint", "result": "int"} +{"name": "/", "left": "int", "right": "tinyint", "result": "int"} +{"name": "/", "left": "int", "right": "bit", "result": "int"} +{"name": "/", "left": "smallint", "right": "float", "result": "float"} +{"name": "/", "left": "smallint", "right": "real", "result": "real"} +{"name": "/", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "smallint", "right": "money", "result": "money"} +{"name": "/", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "smallint", "right": "int", "result": "int"} +{"name": "/", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "/", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "/", "left": "tinyint", "right": "float", "result": "float"} +{"name": "/", "left": "tinyint", "right": "real", "result": "real"} +{"name": "/", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "tinyint", "right": "money", "result": "money"} +{"name": "/", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "tinyint", "right": "int", "result": "int"} +{"name": "/", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "/", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "/", "left": "bit", "right": "float", "result": "float"} +{"name": "/", "left": "bit", "right": "real", "result": "real"} +{"name": "/", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "/", "left": "bit", "right": "money", "result": "money"} +{"name": "/", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "/", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "/", "left": "bit", "right": "int", "result": "int"} +{"name": "/", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "/", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "%", "left": "decimal", "right": "money", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "smallmoney", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "bigint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "int", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "smallint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "tinyint", "result": "decimal"} +{"name": "%", "left": "decimal", "right": "bit", "result": "decimal"} +{"name": "%", "left": "money", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "money", "right": "smallmoney", "result": "money"} +{"name": "%", "left": "money", "right": "bigint", "result": "money"} +{"name": "%", "left": "money", "right": "int", "result": "money"} +{"name": "%", "left": "money", "right": "smallint", "result": "money"} +{"name": "%", "left": "money", "right": "tinyint", "result": "money"} +{"name": "%", "left": "money", "right": "bit", "result": "money"} +{"name": "%", "left": "smallmoney", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "smallmoney", "right": "money", "result": "money"} +{"name": "%", "left": "smallmoney", "right": "bigint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "int", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "smallint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "tinyint", "result": "smallmoney"} +{"name": "%", "left": "smallmoney", "right": "bit", "result": "smallmoney"} +{"name": "%", "left": "bigint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "bigint", "right": "money", "result": "money"} +{"name": "%", "left": "bigint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "bigint", "right": "int", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "smallint", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "tinyint", "result": "bigint"} +{"name": "%", "left": "bigint", "right": "bit", "result": "bigint"} +{"name": "%", "left": "int", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "int", "right": "money", "result": "money"} +{"name": "%", "left": "int", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "int", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "int", "right": "smallint", "result": "int"} +{"name": "%", "left": "int", "right": "tinyint", "result": "int"} +{"name": "%", "left": "int", "right": "bit", "result": "int"} +{"name": "%", "left": "smallint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "smallint", "right": "money", "result": "money"} +{"name": "%", "left": "smallint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "smallint", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "smallint", "right": "int", "result": "int"} +{"name": "%", "left": "smallint", "right": "tinyint", "result": "smallint"} +{"name": "%", "left": "smallint", "right": "bit", "result": "smallint"} +{"name": "%", "left": "tinyint", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "tinyint", "right": "money", "result": "money"} +{"name": "%", "left": "tinyint", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "tinyint", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "tinyint", "right": "int", "result": "int"} +{"name": "%", "left": "tinyint", "right": "smallint", "result": "smallint"} +{"name": "%", "left": "tinyint", "right": "bit", "result": "tinyint"} +{"name": "%", "left": "bit", "right": "decimal", "result": "decimal"} +{"name": "%", "left": "bit", "right": "money", "result": "money"} +{"name": "%", "left": "bit", "right": "smallmoney", "result": "smallmoney"} +{"name": "%", "left": "bit", "right": "bigint", "result": "bigint"} +{"name": "%", "left": "bit", "right": "int", "result": "int"} +{"name": "%", "left": "bit", "right": "smallint", "result": "smallint"} +{"name": "%", "left": "bit", "right": "tinyint", "result": "tinyint"} +{"name": "+", "left": "char", "right": "char", "result": "char"} +{"name": "+", "left": "char", "right": "varchar", "result": "varchar"} +{"name": "+", "left": "char", "right": "nchar", "result": "nchar"} +{"name": "+", "left": "char", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "varchar", "right": "char", "result": "varchar"} +{"name": "+", "left": "varchar", "right": "varchar", "result": "varchar"} +{"name": "+", "left": "varchar", "right": "nchar", "result": "nvarchar"} +{"name": "+", "left": "varchar", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "nchar", "right": "char", "result": "nchar"} +{"name": "+", "left": "nchar", "right": "varchar", "result": "nvarchar"} +{"name": "+", "left": "nchar", "right": "nchar", "result": "nchar"} +{"name": "+", "left": "nchar", "right": "nvarchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "char", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "varchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "nchar", "result": "nvarchar"} +{"name": "+", "left": "nvarchar", "right": "nvarchar", "result": "nvarchar"} diff --git a/internal/engine/mssql/parse.go b/internal/engine/mssql/parse.go index e222708ece..681888dcd2 100644 --- a/internal/engine/mssql/parse.go +++ b/internal/engine/mssql/parse.go @@ -3,13 +3,17 @@ package mssql import ( "bytes" "context" + "fmt" "io" + "regexp" + "strings" "unicode/utf8" "github.com/sqlc-dev/teesql/parser" "github.com/sqlc-dev/sqlc/internal/source" "github.com/sqlc-dev/sqlc/internal/sql/ast" + "github.com/sqlc-dev/sqlc/internal/sql/sqlerr" ) func NewParser() *Parser { @@ -47,10 +51,31 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { converter := &cc{toByte: toByte} out := converter.convert(stmt) if _, ok := out.(*ast.TODO); ok { + // A schema holds statements sqlc has no use for, which are + // skipped. A named query sqlc cannot analyze is an error, + // rather than a query missing from the generated code. + if namedQuery.Match(blob[loc:end]) { + kind := strings.TrimSuffix(strings.TrimPrefix(fmt.Sprintf("%T", stmt), "*ast."), "Statement") + return nil, &sqlerr.Error{ + Message: fmt.Sprintf("%s statements are not supported", kind), + Location: start, + } + } + for _, ddl := range converter.blockSchemaStatements(stmt) { + stmts = append(stmts, ast.Statement{ + Raw: &ast.RawStmt{Stmt: ddl, StmtLocation: loc, StmtLen: end - loc}, + }) + } loc = end continue } + if namedQuery.Match(blob[loc:end]) { + if err := checkPlaceholders(blob, start, end, converter.namedParams); err != nil { + return nil, err + } + } + stmts = append(stmts, ast.Statement{ Raw: &ast.RawStmt{ Stmt: out, @@ -65,6 +90,80 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { return stmts, nil } +// namedQuery matches the comment that names a query, in either comment +// style. +var namedQuery = regexp.MustCompile(`(?m)^\s*(--|/\*)\s*name:\s*\S+`) + +// checkPlaceholders reports a placeholder in a query's text that did not +// become one of its parameters, which a construct the converter does not +// follow drops, leaving generated code that passes the query too few +// arguments. +func checkPlaceholders(blob []byte, start, end int, params map[string]namedParam) error { + for _, p := range placeholders(blob[start:end]) { + if _, ok := params[strings.ToLower(p.name)]; !ok { + return &sqlerr.Error{ + Message: fmt.Sprintf("placeholder @%s is not supported where it is used", p.name), + Location: start + p.offset, + } + } + } + return nil +} + +type placeholder struct { + name string + offset int +} + +// placeholders are the @name placeholders in sql, leaving out @@ system +// variables and anything inside a string, a quoted or bracketed +// identifier or a comment. +func placeholders(sql []byte) []placeholder { + var out []placeholder + skipTo := func(i int, close string) int { + if j := bytes.Index(sql[i:], []byte(close)); j >= 0 { + return i + j + len(close) + } + return len(sql) + } + for i := 0; i < len(sql); { + switch c := sql[i]; { + case c == '\'' || c == '"': + // A doubled quote inside is an escaped one, which the scan + // steps over as the end of one string and the start of the + // next. + i = skipTo(i+1, string(c)) + case c == '[': + i = skipTo(i+1, "]") + case c == '-' && i+1 < len(sql) && sql[i+1] == '-': + i = skipTo(i, "\n") + case c == '/' && i+1 < len(sql) && sql[i+1] == '*': + i = skipTo(i+2, "*/") + case c == '@': + j := i + 1 + for j < len(sql) && isNameByte(sql[j]) { + j++ + } + if i+1 < len(sql) && sql[i+1] == '@' { + i = j + continue + } + if j > i+1 { + out = append(out, placeholder{name: string(sql[i+1 : j]), offset: i}) + } + i = j + default: + i++ + } + } + return out +} + +func isNameByte(b byte) bool { + return b == '_' || b == '#' || b == '$' || b == '@' || + 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' || '0' <= b && b <= '9' || b >= utf8.RuneSelf +} + // byteOffsets returns a function mapping a UTF-16 code-unit offset — how // teesql records source spans, mirroring ScriptDom — to a byte offset in // blob. For ASCII input the two are identical and the identity is returned. diff --git a/internal/sql/ast/coalesce_expr.go b/internal/sql/ast/coalesce_expr.go index f51c2c5c8e..36c1defa3c 100644 --- a/internal/sql/ast/coalesce_expr.go +++ b/internal/sql/ast/coalesce_expr.go @@ -10,6 +10,9 @@ type CoalesceExpr struct { Coalescecollid Oid `json:"coalescecollid"` Args *List `json:"args,omitempty"` Location int `json:"location"` + // FirstArgType marks SQL Server's ISNULL, which takes its first + // argument's type rather than the type its arguments combine to. + FirstArgType bool `json:"first_arg_type,omitempty"` } func (n *CoalesceExpr) Pos() int { 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 ) diff --git a/internal/sql/ast/range_pivot.go b/internal/sql/ast/range_pivot.go new file mode 100644 index 0000000000..f3d7b7a761 --- /dev/null +++ b/internal/sql/ast/range_pivot.go @@ -0,0 +1,56 @@ +package ast + +import "github.com/sqlc-dev/sqlc/internal/sql/format" + +// RangePivot is a FROM item that rotates the rows of another, as SQL +// Server's PIVOT and UNPIVOT do. PIVOT turns the values of ForColumn named +// in InList into columns of Aggregate; UNPIVOT turns the columns in InList +// into rows of ValueColumn, named in ForColumn of type ForType. +type RangePivot struct { + Tag NodeTag[RangePivot] `json:"tag"` + + Source Node `json:"source,omitempty"` + Unpivot bool `json:"unpivot"` + Aggregate *FuncCall `json:"aggregate,omitempty"` + ValueColumn string `json:"value_column"` + ForColumn string `json:"for_column"` + ForType *TypeName `json:"for_type,omitempty"` + InList *List `json:"in_list,omitempty"` + Alias *Alias `json:"alias,omitempty"` +} + +func (n *RangePivot) Pos() int { + return 0 +} + +func (n *RangePivot) Format(buf *TrackedBuffer, d format.Dialect) { + if n == nil { + return + } + buf.astFormat(n.Source, d) + if n.Unpivot { + buf.WriteString(" UNPIVOT (") + buf.WriteString(d.QuoteIdent(n.ValueColumn)) + } else { + buf.WriteString(" PIVOT (") + buf.astFormat(n.Aggregate, d) + } + buf.WriteString(" FOR ") + buf.WriteString(d.QuoteIdent(n.ForColumn)) + buf.WriteString(" IN (") + if n.InList != nil { + for i, item := range n.InList.Items { + if i > 0 { + buf.WriteString(", ") + } + if s, ok := item.(*String); ok { + buf.WriteString(d.QuoteIdent(s.Str)) + } + } + } + buf.WriteString("))") + if n.Alias != nil { + buf.WriteString(" AS ") + buf.astFormat(n.Alias, d) + } +} diff --git a/internal/sql/astutils/rewrite.go b/internal/sql/astutils/rewrite.go index 25b274a16c..d178de1893 100644 --- a/internal/sql/astutils/rewrite.go +++ b/internal/sql/astutils/rewrite.go @@ -967,6 +967,12 @@ func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast. a.apply(n, "Alias", nil, n.Alias) a.apply(n, "Coldeflist", nil, n.Coldeflist) + case *ast.RangePivot: + a.apply(n, "Source", nil, n.Source) + a.apply(n, "Aggregate", nil, n.Aggregate) + a.apply(n, "InList", nil, n.InList) + a.apply(n, "Alias", nil, n.Alias) + case *ast.RangeSubselect: a.apply(n, "Subquery", nil, n.Subquery) a.apply(n, "Alias", nil, n.Alias) diff --git a/internal/sql/astutils/walk.go b/internal/sql/astutils/walk.go index 6d5e80bdc3..dcd5119df5 100644 --- a/internal/sql/astutils/walk.go +++ b/internal/sql/astutils/walk.go @@ -1615,6 +1615,20 @@ func Walk(f Visitor, node ast.Node) { Walk(f, n.Coldeflist) } + case *ast.RangePivot: + if n.Source != nil { + Walk(f, n.Source) + } + if n.Aggregate != nil { + Walk(f, n.Aggregate) + } + if n.InList != nil { + Walk(f, n.InList) + } + if n.Alias != nil { + Walk(f, n.Alias) + } + case *ast.RangeSubselect: if n.Subquery != nil { Walk(f, n.Subquery) diff --git a/internal/sql/preprocess/CLAUDE.md b/internal/sql/preprocess/CLAUDE.md index a7f4d9aafe..cf468c91c0 100644 --- a/internal/sql/preprocess/CLAUDE.md +++ b/internal/sql/preprocess/CLAUDE.md @@ -20,6 +20,7 @@ Native placeholders by dialect: | postgresql | `$1` | sqlc syntax | | mysql | `?` | user variable, left alone | | sqlite | `?1` | sqlc syntax | +| mssql | `@name` | native, kept as written; names compare without regard to case | GoogleSQL and ClickHouse are deliberately absent. They handle their own parameter syntax, so `File` returns their source unchanged and sqlc syntax is @@ -30,9 +31,9 @@ looks like. `lexer` is a dialect-parameterized scanner. It does not parse SQL — it knows only enough to skip the regions where sqlc syntax must not be rewritten: -comments (`--`, `/* */`, `#`), string literals, quoted identifiers, backticks -and PostgreSQL dollar-quoted strings. `Dialect` (dialect.go) is the single -place those lexical rules live. +comments (`--`, `/* */`, `#`), string literals, quoted identifiers, backticks, +SQL Server brackets and PostgreSQL dollar-quoted strings. `Dialect` +(dialect.go) is the single place those lexical rules live. `File(engine, src)` looks up the dialect; an engine with no entry gets its source back untouched. Otherwise it walks the whole file, splits it at diff --git a/internal/sql/preprocess/dialect.go b/internal/sql/preprocess/dialect.go index 4d8d4ae85b..3ed78281dd 100644 --- a/internal/sql/preprocess/dialect.go +++ b/internal/sql/preprocess/dialect.go @@ -14,6 +14,8 @@ const ( StyleQuestion // StyleOrdinal numbers parameters as ?1, ?2, ... (SQLite) StyleOrdinal + // StyleAt names parameters as @name (SQL Server) + StyleAt ) // Dialect describes the lexical rules the preprocessor needs to walk a query @@ -42,6 +44,10 @@ type Dialect struct { // Backtick reports whether `ident` is a quoted identifier. Backtick bool + // Bracket reports whether [ident] is a quoted identifier, with ]] + // standing for a closing bracket in it. + Bracket bool + // HashComment reports whether # starts a line comment. HashComment bool @@ -88,6 +94,14 @@ var dialects = map[config.Engine]Dialect{ Backtick: true, Backslash: true, }, + // SQL Server's @name is already a named parameter, so sqlc.arg(name) + // becomes one. Its comments nest and its identifiers keep their case. + config.EngineMSSQL: { + Style: StyleAt, + AtSign: true, + Bracket: true, + NestedBlockComment: true, + }, // ClickHouse binds with an unnumbered ?, like MySQL, and its identifiers // keep their case. config.EngineClickHouse: { diff --git a/internal/sql/preprocess/lexer.go b/internal/sql/preprocess/lexer.go index d17d80b077..7c9568c3c2 100644 --- a/internal/sql/preprocess/lexer.go +++ b/internal/sql/preprocess/lexer.go @@ -53,6 +53,11 @@ func (l *lexer) skip(i int) int { return -1 } return l.skipQuoted(i, '`', false) + case '[': + if !l.d.Bracket { + return -1 + } + return l.skipQuoted(i, ']', false) case '-': if l.at(i+1) == '-' { return l.skipLine(i) diff --git a/internal/sql/preprocess/preprocess.go b/internal/sql/preprocess/preprocess.go index ad25bc9b2f..ff9c92880a 100644 --- a/internal/sql/preprocess/preprocess.go +++ b/internal/sql/preprocess/preprocess.go @@ -347,11 +347,22 @@ func number(d Dialect, occs []occurrence) *named.ParamSet { numbs[occ.number] = true } ps := named.NewParamSet(numbs, d.hasNamedSupport()) + // SQL Server compares parameter names without regard to case, so @Name + // and @name are one parameter, named by its first spelling. + spelling := map[string]string{} for i := range occs { occ := &occs[i] if occ.kind == kindEmbed || occ.kind == kindNative { continue } + if d.Style == StyleAt { + key := strings.ToLower(occ.name) + if first, ok := spelling[key]; ok { + occ.name = first + } else { + spelling[key] = occ.name + } + } occ.number = ps.Add(param(occ)) } return ps @@ -389,6 +400,15 @@ func (d Dialect) replacement(occ *occurrence) string { return fmt.Sprintf("/*SLICE:%s*/?", occ.name) } return fmt.Sprintf("?%d", occ.number) + case StyleAt: + if occ.kind == kindSlice { + return fmt.Sprintf("/*SLICE:%s*/@%s", occ.name, occ.name) + } + // A bare @name is already native; keep the spelling the user wrote. + if strings.HasPrefix(occ.ident, "@") { + return occ.ident + } + return "@" + occ.name default: if occ.kind == kindSlice { return fmt.Sprintf("/*SLICE:%s*/?", occ.name) diff --git a/internal/sql/preprocess/scan.go b/internal/sql/preprocess/scan.go index b2b4b1f534..026899ed58 100644 --- a/internal/sql/preprocess/scan.go +++ b/internal/sql/preprocess/scan.go @@ -33,8 +33,14 @@ func (l *lexer) scan(start, end int) []occurrence { } i = j - case c == '@' && l.d.AtSign && isIdentStart(l.at(i+1)): + // @@name is a system function, such as SQL Server's @@ROWCOUNT. + case c == '@' && l.d.AtSign && isIdentStart(l.at(i+1)) && l.at(i-1) != '@': j := l.identEnd(i + 1) + // A SQL Server name goes on through #, $ and @, so @a and @a#b + // are two parameters. + for l.d.Style == StyleAt && j < len(l.src) && (isIdentPart(l.src[j]) || strings.IndexByte("#$@", l.src[j]) >= 0) { + j++ + } out = append(out, occurrence{ kind: kindArg, start: i, @@ -138,11 +144,33 @@ func (l *lexer) sqlcCall(start, afterSqlc int) (occurrence, int, bool) { } return occ, occ.end, true } + // A dialect that binds @name writes the name into the query, so it has + // to read back as one parameter: @user-id would be a subtraction. An + // embed names a table, not a parameter. + if l.d.Style == StyleAt && fn != "embed" && !isParamName(name) { + occ.err = &sqlerr.Error{ + Message: fmt.Sprintf("parameter name %q passed to sqlc.%s is not a valid @name; use letters, digits and underscores", name, fn), + Location: start, + } + return occ, occ.end, true + } occ.name = name occ.ident = ident return occ, occ.end, true } +func isParamName(name string) bool { + if name == "" || !isIdentStart(name[0]) { + return false + } + for i := 1; i < len(name); i++ { + if !isIdentPart(name[i]) { + return false + } + } + return true +} + // argument interprets the single argument to a sqlc function. It returns the // parameter name and the text to reuse when rebuilding a reference, which keeps // any identifier quoting the user wrote. diff --git a/internal/sql/preprocess/testdata/mssql/arg/input.sql b/internal/sql/preprocess/testdata/mssql/arg/input.sql new file mode 100644 index 0000000000..c689beee0c --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = sqlc.arg(x) AND b = sqlc.narg(y); diff --git a/internal/sql/preprocess/testdata/mssql/arg/output.sql b/internal/sql/preprocess/testdata/mssql/arg/output.sql new file mode 100644 index 0000000000..9dd09b1637 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @x AND b = @y; diff --git a/internal/sql/preprocess/testdata/mssql/arg/side_table.json b/internal/sql/preprocess/testdata/mssql/arg/side_table.json new file mode 100644 index 0000000000..a67d864ad8 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/arg/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 45, + "dollar": true, + "params": [ + { + "number": 1, + "location": 31, + "origin": 31, + "name": "x", + "named": true + }, + { + "number": 2, + "location": 42, + "origin": 51, + "name": "y", + "named": true, + "nullable": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql new file mode 100644 index 0000000000..f67f702a35 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @Name AND b = sqlc.arg(name) AND c = @NAME; diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql new file mode 100644 index 0000000000..145c90ded9 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE a = @Name AND b = @Name AND c = @NAME; diff --git a/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json new file mode 100644 index 0000000000..438b1d69e2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/at_sign_keeps_spelling/side_table.json @@ -0,0 +1,30 @@ +[ + { + "start": 0, + "end": 65, + "dollar": true, + "params": [ + { + "number": 1, + "location": 31, + "origin": 31, + "name": "Name", + "named": true + }, + { + "number": 1, + "location": 45, + "origin": 45, + "name": "Name", + "named": true + }, + { + "number": 1, + "location": 59, + "origin": 68, + "name": "Name", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/embed/input.sql b/internal/sql/preprocess/testdata/mssql/embed/input.sql new file mode 100644 index 0000000000..34ec985f7f --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/input.sql @@ -0,0 +1 @@ +SELECT sqlc.embed(users) FROM users WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed/output.sql b/internal/sql/preprocess/testdata/mssql/embed/output.sql new file mode 100644 index 0000000000..7493847494 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/output.sql @@ -0,0 +1 @@ +SELECT users.* FROM users WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed/side_table.json b/internal/sql/preprocess/testdata/mssql/embed/side_table.json new file mode 100644 index 0000000000..fdd0a53517 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 41, + "dollar": true, + "params": [ + { + "number": 1, + "location": 37, + "origin": 47, + "name": "id", + "named": true + } + ], + "embeds": [ + { + "table": "users", + "location": 7, + "origin": 7, + "orig": "sqlc.embed(users)" + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql new file mode 100644 index 0000000000..1d03b5f520 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/input.sql @@ -0,0 +1 @@ +SELECT sqlc.embed("order details") FROM [order details] WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql new file mode 100644 index 0000000000..5554ca972b --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/output.sql @@ -0,0 +1 @@ +SELECT "order details".* FROM [order details] WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json new file mode 100644 index 0000000000..4baa50e0c2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/embed_quoted_table/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 61, + "dollar": true, + "params": [ + { + "number": 1, + "location": 57, + "origin": 67, + "name": "id", + "named": true + } + ], + "embeds": [ + { + "table": "order details", + "location": 7, + "origin": 7, + "orig": "sqlc.embed(\"order details\")" + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql new file mode 100644 index 0000000000..5e5891a8b2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/input.sql @@ -0,0 +1,2 @@ +-- name: Bad :many +SELECT id FROM t WHERE user_id = sqlc.arg('user-id') - 1; diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql new file mode 100644 index 0000000000..5e5891a8b2 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/output.sql @@ -0,0 +1,2 @@ +-- name: Bad :many +SELECT id FROM t WHERE user_id = sqlc.arg('user-id') - 1; diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json new file mode 100644 index 0000000000..e0e4768647 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/side_table.json @@ -0,0 +1,9 @@ +[ + { + "start": 0, + "end": 76, + "dollar": true, + "error": "parameter name \"user-id\" passed to sqlc.arg is not a valid @name; use letters, digits and underscores", + "error_at": 52 + } +] diff --git a/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt new file mode 100644 index 0000000000..89416c54d3 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/error_invalid_param_name/stderr.txt @@ -0,0 +1 @@ +2:34: parameter name "user-id" passed to sqlc.arg is not a valid @name; use letters, digits and underscores diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql b/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql new file mode 100644 index 0000000000..4cd1e4dc34 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id = @a AND parent = @a#b AND other = @a$c; diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql b/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql new file mode 100644 index 0000000000..4cd1e4dc34 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id = @a AND parent = @a#b AND other = @a$c; diff --git a/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json b/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json new file mode 100644 index 0000000000..fe5e7ecea4 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/names_with_hash/side_table.json @@ -0,0 +1,30 @@ +[ + { + "start": 0, + "end": 70, + "dollar": true, + "params": [ + { + "number": 1, + "location": 32, + "origin": 32, + "name": "a", + "named": true + }, + { + "number": 2, + "location": 48, + "origin": 48, + "name": "a#b", + "named": true + }, + { + "number": 3, + "location": 65, + "origin": 65, + "name": "a$c", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql new file mode 100644 index 0000000000..cadc2e6fac --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/input.sql @@ -0,0 +1,2 @@ +-- name: Bracketed :many +SELECT [sqlc.arg(x)], [a;b], [@id], [x]]@y] FROM t WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql new file mode 100644 index 0000000000..cadc2e6fac --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/output.sql @@ -0,0 +1,2 @@ +-- name: Bracketed :many +SELECT [sqlc.arg(x)], [a;b], [@id], [x]]@y] FROM t WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json new file mode 100644 index 0000000000..b66e867f66 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_bracketed_identifiers/side_table.json @@ -0,0 +1,16 @@ +[ + { + "start": 0, + "end": 91, + "dollar": true, + "params": [ + { + "number": 1, + "location": 87, + "origin": 87, + "name": "id", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql new file mode 100644 index 0000000000..cd8a15e7bf --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/input.sql @@ -0,0 +1 @@ +SELECT id FROM users /* outer /* sqlc.arg(a) */ @b */ WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql new file mode 100644 index 0000000000..cd8a15e7bf --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/output.sql @@ -0,0 +1 @@ +SELECT id FROM users /* outer /* sqlc.arg(a) */ @b */ WHERE id = @id; diff --git a/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json new file mode 100644 index 0000000000..94445664da --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/skip_nested_block_comment/side_table.json @@ -0,0 +1,16 @@ +[ + { + "start": 0, + "end": 69, + "dollar": true, + "params": [ + { + "number": 1, + "location": 65, + "origin": 65, + "name": "id", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/slice/input.sql b/internal/sql/preprocess/testdata/mssql/slice/input.sql new file mode 100644 index 0000000000..6a76a052a4 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/input.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id IN (sqlc.slice(ids)) AND name = @name; diff --git a/internal/sql/preprocess/testdata/mssql/slice/output.sql b/internal/sql/preprocess/testdata/mssql/slice/output.sql new file mode 100644 index 0000000000..2816aaef80 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/output.sql @@ -0,0 +1 @@ +SELECT id FROM users WHERE id IN (/*SLICE:ids*/@ids) AND name = @name; diff --git a/internal/sql/preprocess/testdata/mssql/slice/side_table.json b/internal/sql/preprocess/testdata/mssql/slice/side_table.json new file mode 100644 index 0000000000..32867f1747 --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/slice/side_table.json @@ -0,0 +1,24 @@ +[ + { + "start": 0, + "end": 70, + "dollar": true, + "params": [ + { + "number": 1, + "location": 47, + "origin": 34, + "name": "ids", + "named": true, + "slice": true + }, + { + "number": 2, + "location": 64, + "origin": 62, + "name": "name", + "named": true + } + ] + } +] diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql new file mode 100644 index 0000000000..89714db7ab --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/input.sql @@ -0,0 +1 @@ +UPDATE users SET name = @name WHERE id = @id; SELECT @@ROWCOUNT; diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql new file mode 100644 index 0000000000..89714db7ab --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/output.sql @@ -0,0 +1 @@ +UPDATE users SET name = @name WHERE id = @id; SELECT @@ROWCOUNT; diff --git a/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json new file mode 100644 index 0000000000..ad18705e8f --- /dev/null +++ b/internal/sql/preprocess/testdata/mssql/system_functions_are_not_parameters/side_table.json @@ -0,0 +1,28 @@ +[ + { + "start": 0, + "end": 45, + "dollar": true, + "params": [ + { + "number": 1, + "location": 24, + "origin": 24, + "name": "name", + "named": true + }, + { + "number": 2, + "location": 41, + "origin": 41, + "name": "id", + "named": true + } + ] + }, + { + "start": 45, + "end": 64, + "dollar": true + } +] diff --git a/internal/sql/validate/cmd.go b/internal/sql/validate/cmd.go index e9d9dd03cb..0837965405 100644 --- a/internal/sql/validate/cmd.go +++ b/internal/sql/validate/cmd.go @@ -27,7 +27,7 @@ func validateCopyfrom(n ast.Node) error { if !ok { return nil } - if len(sel.FromClause.Items) > 0 { + if sel.FromClause != nil && len(sel.FromClause.Items) > 0 { return errors.New(":copyfrom is not compatible with INSERT INTO ... SELECT") } if sel.ValuesLists == nil || len(sel.ValuesLists.Items) != 1 {