diff --git a/internal/cmd/generate.go b/internal/cmd/generate.go index fbdb084409..7c700d2e1f 100644 --- a/internal/cmd/generate.go +++ b/internal/cmd/generate.go @@ -343,7 +343,8 @@ func codegen(ctx context.Context, combo config.CombinedSettings, sql OutputPair, case sql.Gen.Go != nil: out = combo.Go.Out - handler = ext.HandleFunc(golang.Generate) + generator := golang.Generator{TypeMapper: result.GoTypeMapper} + handler = ext.HandleFunc(generator.Generate) opts, err := json.Marshal(sql.Gen.Go) if err != nil { return "", nil, fmt.Errorf("opts marshal failed: %w", err) diff --git a/internal/codegen/golang/driver.go b/internal/codegen/golang/driver.go index 28c0098bea..8d0b942259 100644 --- a/internal/codegen/golang/driver.go +++ b/internal/codegen/golang/driver.go @@ -39,9 +39,8 @@ func usesPqArrays(engine string, driver opts.SQLDriver) bool { return !driver.IsPGX() } -// usesDriverTypes reports whether the engine is one whose mapper reads the -// type expression and draws types from its driver's packages, the ones in -// driverTypes. These engines generate code for database/sql only. +// usesDriverTypes identifies database/sql bindings that scan arrays directly +// instead of using lib/pq's wrappers. func usesDriverTypes(engine string) bool { switch engine { case engineClickHouse, engineDuckDB, engineGoogleSQL, engineMSSQL: diff --git a/internal/codegen/golang/gen.go b/internal/codegen/golang/gen.go index 725f5970cf..d3a14fcc49 100644 --- a/internal/codegen/golang/gen.go +++ b/internal/codegen/golang/gen.go @@ -14,6 +14,7 @@ import ( "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" "github.com/sqlc-dev/sqlc/internal/codegen/sdk" "github.com/sqlc-dev/sqlc/internal/metadata" + sqlopts "github.com/sqlc-dev/sqlc/internal/opts" "github.com/sqlc-dev/sqlc/internal/plugin" ) @@ -110,11 +111,20 @@ func (t *tmplCtx) codegenQueryRetval(q Query) (string, error) { } } +type Generator struct { + TypeMapper sqlopts.GoTypeMapper +} + func Generate(ctx context.Context, req *plugin.GenerateRequest) (*plugin.GenerateResponse, error) { + return (Generator{}).Generate(ctx, req) +} + +func (g Generator) Generate(ctx context.Context, req *plugin.GenerateRequest) (*plugin.GenerateResponse, error) { options, err := opts.Parse(req) if err != nil { return nil, err } + options.TypeMapper = g.TypeMapper if err := opts.ValidateOpts(options); err != nil { return nil, err diff --git a/internal/codegen/golang/go_type.go b/internal/codegen/golang/go_type.go index 257ed99869..035aec8169 100644 --- a/internal/codegen/golang/go_type.go +++ b/internal/codegen/golang/go_type.go @@ -95,7 +95,16 @@ func goInnerType(req *plugin.GenerateRequest, options *opts.Options, col *plugin } } - // TODO: Extend the engine interface to handle types + if options.TypeMapper != nil { + t, nullable := columnType(col) + mapped := options.TypeMapper.GoType(t, param) + typ := mapped.Type + if mapped.NullableType != "" { + typ = nullableGoType(options, nullable, typ, mapped.NullableType) + } + return typ, mapped.Complete + } + switch req.Settings.Engine { case engineMySQL: return mysqlType(req, options, col), false @@ -109,8 +118,6 @@ func goInnerType(req *plugin.GenerateRequest, options *opts.Options, col *plugin return duckdbType(req, options, col, param), true case engineGoogleSQL: return googlesqlType(req, options, col), true - case engineMSSQL: - return mssqlType(req, options, col), true default: return "any", false } diff --git a/internal/codegen/golang/imports.go b/internal/codegen/golang/imports.go index e1370e48eb..e8ebb7fb98 100644 --- a/internal/codegen/golang/imports.go +++ b/internal/codegen/golang/imports.go @@ -157,13 +157,12 @@ var stdlibTypes = map[string]string{ "big.Rat": "math/big", } -// driverTypes are the packages the ClickHouse, DuckDB, Spanner and SQL -// Server mappers draw types from, by the qualifier those types carry. +// driverTypes are the packages the legacy mappers draw types from, by the +// qualifier those types carry. var driverTypes = map[string]string{ "civil.": "cloud.google.com/go/civil", "decimal.": "github.com/shopspring/decimal", "duckdb.": "github.com/duckdb/duckdb-go/v2", - "mssql.": "github.com/microsoft/go-mssqldb", "orb.": "github.com/paulmach/orb", "spanner.": "cloud.google.com/go/spanner", } @@ -242,8 +241,12 @@ func buildImports(options *opts.Options, engine string, queries []Query, uses fu // them, and an override whose type carries the same qualifier brings // its own import: a PostgreSQL numeric overridden to another package's // decimal.Decimal must not pull in shopspring's as well. - if usesDriverTypes(engine) { - for qualifier, path := range driverTypes { + typeImports := driverTypes + if options.TypeMapper != nil { + typeImports = options.TypeMapper.GoTypeImports() + } + if options.TypeMapper != nil || usesDriverTypes(engine) { + for qualifier, path := range typeImports { if uses(qualifier) && !overrideHasQualifier(overrideTypes, qualifier) { pkg[ImportSpec{Path: path}] = struct{}{} } diff --git a/internal/codegen/golang/mssql_type.go b/internal/codegen/golang/mssql_type.go deleted file mode 100644 index 94492f58e9..0000000000 --- a/internal/codegen/golang/mssql_type.go +++ /dev/null @@ -1,65 +0,0 @@ -package golang - -import ( - "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" - "github.com/sqlc-dev/sqlc/internal/plugin" -) - -// 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 -// 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 -// until it does. -func mssqlType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Column) string { - t, nullable := columnType(col) - null := func(typ, nullTyp string) string { - return nullableGoType(options, nullable, typ, nullTyp) - } - - switch typeExprName(t) { - case "bigint": - return null("int64", "sql.NullInt64") - - case "int": - return null("int32", "sql.NullInt32") - - case "smallint": - return null("int16", "sql.NullInt16") - - case "tinyint": - return null("uint8", "sql.NullByte") - - case "bit": - return null("bool", "sql.NullBool") - - case "decimal", "numeric", "money", "smallmoney": - return null("string", "sql.NullString") - - case "float": - return null("float64", "sql.NullFloat64") - - case "real": - return null("float32", "sql.NullFloat64") - - case "char", "varchar", "nchar", "nvarchar", "text", "ntext", "sysname", "xml", "json": - return null("string", "sql.NullString") - - case "binary", "varbinary", "image", "rowversion", "timestamp": - return "[]byte" - - case "date", "datetime", "datetime2", "smalldatetime", "datetimeoffset", "time": - return null("time.Time", "sql.NullTime") - - case "uniqueidentifier": - return null("mssql.UniqueIdentifier", "mssql.NullUniqueIdentifier") - - case "geography", "geometry", "hierarchyid", "vector": - return "[]byte" - - default: - return "any" - } -} diff --git a/internal/codegen/golang/opts/options.go b/internal/codegen/golang/opts/options.go index 64ceb13796..5de000d226 100644 --- a/internal/codegen/golang/opts/options.go +++ b/internal/codegen/golang/opts/options.go @@ -6,6 +6,7 @@ import ( "maps" "path/filepath" + sqlopts "github.com/sqlc-dev/sqlc/internal/opts" "github.com/sqlc-dev/sqlc/internal/plugin" ) @@ -52,7 +53,8 @@ type Options struct { BuildTags string `json:"build_tags,omitempty" yaml:"build_tags"` Initialisms *[]string `json:"initialisms,omitempty" yaml:"initialisms"` - InitialismsMap map[string]struct{} `json:"-" yaml:"-"` + InitialismsMap map[string]struct{} `json:"-" yaml:"-"` + TypeMapper sqlopts.GoTypeMapper `json:"-" yaml:"-"` } type GlobalOptions struct { 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/compiler/compile.go b/internal/compiler/compile.go index b6f703d1cb..1e4108bc1f 100644 --- a/internal/compiler/compile.go +++ b/internal/compiler/compile.go @@ -240,9 +240,11 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) { return nil, fmt.Errorf("no queries contained in paths %s", strings.Join(c.conf.Queries, ",")) } + typeMapper, _ := c.parser.(opts.GoTypeMapper) return &Result{ - Catalog: c.catalog, - Queries: q, + GoTypeMapper: typeMapper, + Catalog: c.catalog, + Queries: q, }, nil } diff --git a/internal/compiler/result.go b/internal/compiler/result.go index 3647da630f..fa9885b08b 100644 --- a/internal/compiler/result.go +++ b/internal/compiler/result.go @@ -1,10 +1,12 @@ package compiler import ( + "github.com/sqlc-dev/sqlc/internal/opts" "github.com/sqlc-dev/sqlc/internal/sql/catalog" ) type Result struct { - Catalog *catalog.Catalog - Queries []*Query + Catalog *catalog.Catalog + Queries []*Query + GoTypeMapper opts.GoTypeMapper } 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_go_type_mapping/mssql/exec.json b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/exec.json new file mode 100644 index 0000000000..2e996ca79d --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/exec.json @@ -0,0 +1,3 @@ +{ + "contexts": ["base"] +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/db.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/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_go_type_mapping/mssql/go/models.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/models.go new file mode 100644 index 0000000000..257f84cad8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/models.go @@ -0,0 +1,16 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +type Balance struct { + Amount mssql.Money[decimal.Decimal] + OptionalAmount mssql.Money[decimal.NullDecimal] + Token *mssql.UniqueIdentifier +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/querier.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/querier.go new file mode 100644 index 0000000000..68ae217f55 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/querier.go @@ -0,0 +1,20 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +type Querier interface { + GetAmount(ctx context.Context, amount mssql.Money[decimal.Decimal]) (mssql.Money[decimal.Decimal], error) + GetBalance(ctx context.Context, token *mssql.UniqueIdentifier) (Balance, error) + SetOptional(ctx context.Context, arg SetOptionalParams) error +} + +var _ Querier = (*Queries)(nil) diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/query.sql.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/query.sql.go new file mode 100644 index 0000000000..73b5cecf7c --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go/query.sql.go @@ -0,0 +1,50 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +const getAmount = `-- name: GetAmount :one +SELECT amount FROM balances WHERE amount = @amount; +` + +func (q *Queries) GetAmount(ctx context.Context, amount mssql.Money[decimal.Decimal]) (mssql.Money[decimal.Decimal], error) { + row := q.db.QueryRowContext(ctx, getAmount, sql.Named("amount", amount)) + var amount_2 mssql.Money[decimal.Decimal] + err := row.Scan(&amount_2) + return amount_2, err +} + +const getBalance = `-- name: GetBalance :one +SELECT amount, optional_amount, token FROM balances WHERE token = @token; +` + +func (q *Queries) GetBalance(ctx context.Context, token *mssql.UniqueIdentifier) (Balance, error) { + row := q.db.QueryRowContext(ctx, getBalance, sql.Named("token", token)) + var i Balance + err := row.Scan(&i.Amount, &i.OptionalAmount, &i.Token) + return i, err +} + +const setOptional = `-- name: SetOptional :exec +UPDATE balances SET optional_amount = @optional_amount WHERE token = @token; +` + +type SetOptionalParams struct { + OptionalAmount mssql.Money[decimal.NullDecimal] + Token *mssql.UniqueIdentifier +} + +func (q *Queries) SetOptional(ctx context.Context, arg SetOptionalParams) error { + _, err := q.db.ExecContext(ctx, setOptional, sql.Named("optional_amount", arg.OptionalAmount), sql.Named("token", arg.Token)) + return err +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/db.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/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_go_type_mapping/mssql/go_overrides/models.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/models.go new file mode 100644 index 0000000000..7fbff97e6a --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/models.go @@ -0,0 +1,15 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "github.com/sqlc-dev/sqlc/endtoend/overrides_decimal_package/decimal" +) + +type Balance struct { + Amount decimal.Decimal + OptionalAmount decimal.Decimal + Token string +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/querier.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/querier.go new file mode 100644 index 0000000000..8a63d5e8ea --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/querier.go @@ -0,0 +1,19 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + + "github.com/sqlc-dev/sqlc/endtoend/overrides_decimal_package/decimal" +) + +type Querier interface { + GetAmount(ctx context.Context, amount decimal.Decimal) (decimal.Decimal, error) + GetBalance(ctx context.Context, token string) (Balance, error) + SetOptional(ctx context.Context, arg SetOptionalParams) error +} + +var _ Querier = (*Queries)(nil) diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/query.sql.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/query.sql.go new file mode 100644 index 0000000000..315f15c182 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_overrides/query.sql.go @@ -0,0 +1,49 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" + + "github.com/sqlc-dev/sqlc/endtoend/overrides_decimal_package/decimal" +) + +const getAmount = `-- name: GetAmount :one +SELECT amount FROM balances WHERE amount = @amount; +` + +func (q *Queries) GetAmount(ctx context.Context, amount decimal.Decimal) (decimal.Decimal, error) { + row := q.db.QueryRowContext(ctx, getAmount, sql.Named("amount", amount)) + var amount_2 decimal.Decimal + err := row.Scan(&amount_2) + return amount_2, err +} + +const getBalance = `-- name: GetBalance :one +SELECT amount, optional_amount, token FROM balances WHERE token = @token; +` + +func (q *Queries) GetBalance(ctx context.Context, token string) (Balance, error) { + row := q.db.QueryRowContext(ctx, getBalance, sql.Named("token", token)) + var i Balance + err := row.Scan(&i.Amount, &i.OptionalAmount, &i.Token) + return i, err +} + +const setOptional = `-- name: SetOptional :exec +UPDATE balances SET optional_amount = @optional_amount WHERE token = @token; +` + +type SetOptionalParams struct { + OptionalAmount decimal.Decimal + Token string +} + +func (q *Queries) SetOptional(ctx context.Context, arg SetOptionalParams) error { + _, err := q.db.ExecContext(ctx, setOptional, sql.Named("optional_amount", arg.OptionalAmount), sql.Named("token", arg.Token)) + return err +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/db.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/db.go new file mode 100644 index 0000000000..32faa9f2b8 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/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_go_type_mapping/mssql/go_pointers/models.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/models.go new file mode 100644 index 0000000000..67379c8d75 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/models.go @@ -0,0 +1,16 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +type Balance struct { + Amount mssql.Money[decimal.Decimal] + OptionalAmount *mssql.Money[decimal.Decimal] + Token *mssql.UniqueIdentifier +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/querier.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/querier.go new file mode 100644 index 0000000000..68ae217f55 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/querier.go @@ -0,0 +1,20 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package querytest + +import ( + "context" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +type Querier interface { + GetAmount(ctx context.Context, amount mssql.Money[decimal.Decimal]) (mssql.Money[decimal.Decimal], error) + GetBalance(ctx context.Context, token *mssql.UniqueIdentifier) (Balance, error) + SetOptional(ctx context.Context, arg SetOptionalParams) error +} + +var _ Querier = (*Queries)(nil) diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/query.sql.go b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/query.sql.go new file mode 100644 index 0000000000..e1feb1a000 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/go_pointers/query.sql.go @@ -0,0 +1,50 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package querytest + +import ( + "context" + "database/sql" + + "github.com/microsoft/go-mssqldb" + "github.com/shopspring/decimal" +) + +const getAmount = `-- name: GetAmount :one +SELECT amount FROM balances WHERE amount = @amount; +` + +func (q *Queries) GetAmount(ctx context.Context, amount mssql.Money[decimal.Decimal]) (mssql.Money[decimal.Decimal], error) { + row := q.db.QueryRowContext(ctx, getAmount, sql.Named("amount", amount)) + var amount_2 mssql.Money[decimal.Decimal] + err := row.Scan(&amount_2) + return amount_2, err +} + +const getBalance = `-- name: GetBalance :one +SELECT amount, optional_amount, token FROM balances WHERE token = @token; +` + +func (q *Queries) GetBalance(ctx context.Context, token *mssql.UniqueIdentifier) (Balance, error) { + row := q.db.QueryRowContext(ctx, getBalance, sql.Named("token", token)) + var i Balance + err := row.Scan(&i.Amount, &i.OptionalAmount, &i.Token) + return i, err +} + +const setOptional = `-- name: SetOptional :exec +UPDATE balances SET optional_amount = @optional_amount WHERE token = @token; +` + +type SetOptionalParams struct { + OptionalAmount *mssql.Money[decimal.Decimal] + Token *mssql.UniqueIdentifier +} + +func (q *Queries) SetOptional(ctx context.Context, arg SetOptionalParams) error { + _, err := q.db.ExecContext(ctx, setOptional, sql.Named("optional_amount", arg.OptionalAmount), sql.Named("token", arg.Token)) + return err +} diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/query.sql b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/query.sql new file mode 100644 index 0000000000..983c4c5469 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/query.sql @@ -0,0 +1,8 @@ +-- name: GetAmount :one +SELECT amount FROM balances WHERE amount = @amount; + +-- name: GetBalance :one +SELECT * FROM balances WHERE token = @token; + +-- name: SetOptional :exec +UPDATE balances SET optional_amount = @optional_amount WHERE token = @token; diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/schema.sql b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/schema.sql new file mode 100644 index 0000000000..1855efd46b --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE balances ( + amount MONEY NOT NULL, + optional_amount SMALLMONEY, + token UNIQUEIDENTIFIER +); diff --git a/internal/endtoend/testdata/mssql_go_type_mapping/mssql/sqlc.yaml b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/sqlc.yaml new file mode 100644 index 0000000000..fc0a995b09 --- /dev/null +++ b/internal/endtoend/testdata/mssql_go_type_mapping/mssql/sqlc.yaml @@ -0,0 +1,34 @@ +version: "2" +sql: + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go" + emit_interface: true + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go_pointers" + emit_interface: true + emit_pointers_for_null_types: true + - engine: "mssql" + schema: "schema.sql" + queries: "query.sql" + gen: + go: + package: "querytest" + out: "go_overrides" + emit_interface: true + overrides: + - db_type: "money" + go_type: "github.com/sqlc-dev/sqlc/endtoend/overrides_decimal_package/decimal.Decimal" + - column: "balances.optional_amount" + go_type: "github.com/sqlc-dev/sqlc/endtoend/overrides_decimal_package/decimal.Decimal" + - column: "balances.token" + go_type: "string" 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..13c50d4686 --- /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 SUM(amount) AS [2023] FROM sales; +` + +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..5cd729e6cc --- /dev/null +++ b/internal/endtoend/testdata/mssql_result_variable_name/mssql/query.sql @@ -0,0 +1,11 @@ +-- name: Sales2023 :many +SELECT SUM(amount) AS [2023] FROM sales; + +-- 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/engine/mssql/go_type.go b/internal/engine/mssql/go_type.go new file mode 100644 index 0000000000..7ecec2d8a1 --- /dev/null +++ b/internal/engine/mssql/go_type.go @@ -0,0 +1,73 @@ +package mssql + +import ( + "strings" + + "github.com/sqlc-dev/sqlc/internal/opts" + "github.com/sqlc-dev/sqlc/internal/plugin" +) + +// GoType describes the Go representations used by the go-mssqldb binding. +// Alias types remain any until the catalog resolves them to their base types. +func (p *Parser) GoType(t *plugin.TypeExpr, parameter bool) opts.GoType { + mapped := func(typ, nullTyp string) opts.GoType { + return opts.GoType{Type: typ, NullableType: nullTyp, Complete: true} + } + + switch strings.ToLower(t.GetName()) { + case "bigint": + return mapped("int64", "sql.NullInt64") + + case "int": + return mapped("int32", "sql.NullInt32") + + case "smallint": + return mapped("int16", "sql.NullInt16") + + case "tinyint": + return mapped("uint8", "sql.NullByte") + + case "bit": + return mapped("bool", "sql.NullBool") + + case "decimal", "numeric": + return mapped("decimal.Decimal", "decimal.NullDecimal") + + case "money", "smallmoney": + return mapped("mssql.Money[decimal.Decimal]", "mssql.Money[decimal.NullDecimal]") + + case "float": + return mapped("float64", "sql.NullFloat64") + + case "real": + return mapped("float32", "sql.NullFloat64") + + case "char", "varchar", "nchar", "nvarchar", "text", "ntext", "sysname", "xml", "json": + return mapped("string", "sql.NullString") + + case "binary", "varbinary", "image", "rowversion", "timestamp": + return mapped("[]byte", "") + + case "date", "datetime", "datetime2", "smalldatetime", "datetimeoffset", "time": + return mapped("time.Time", "sql.NullTime") + + case "uniqueidentifier": + // 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 mapped("mssql.UniqueIdentifier", "*mssql.UniqueIdentifier") + + case "geography", "geometry", "hierarchyid", "vector": + return mapped("[]byte", "") + + default: + return mapped("any", "") + } +} + +func (p *Parser) GoTypeImports() map[string]string { + return map[string]string{ + "decimal.": "github.com/shopspring/decimal", + "mssql.": "github.com/microsoft/go-mssqldb", + } +} diff --git a/internal/opts/go_type.go b/internal/opts/go_type.go new file mode 100644 index 0000000000..4da5baa323 --- /dev/null +++ b/internal/opts/go_type.go @@ -0,0 +1,20 @@ +package opts + +import "github.com/sqlc-dev/sqlc/internal/plugin" + +// GoType describes a driver's value type and, when needed, its nullable wrapper. +// An empty NullableType means Type already represents nullable values. +// Complete means the type already includes any array dimensions. +type GoType struct { + Type string + NullableType string + Complete bool +} + +// GoTypeMapper optionally replaces an engine's built-in Go type mapping. +// GoTypeImports maps dependency package qualifiers (including the trailing dot) to +// import paths. User overrides retain precedence over both types and imports. +type GoTypeMapper interface { + GoType(t *plugin.TypeExpr, parameter bool) GoType + GoTypeImports() map[string]string +}