snapshot of https://github.com/sqlc-dev/sqlc.git (main, 2026-09-16; blobs > 131072B omitted)

internal/endtoend/testdata/omit_unused_structs/postgresql/stdlib/go/db.go

@@ -0,0 +1,31 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+
+package db
+
+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,
+	}
+}

internal/endtoend/testdata/omit_unused_structs/postgresql/stdlib/go/models.go

@@ -0,0 +1,325 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+
+package db
+
+import (
+	"database/sql/driver"
+	"fmt"
+)
+
+type ArrayEnum string
+
+const (
+	ArrayEnumO ArrayEnum = "o"
+	ArrayEnumP ArrayEnum = "p"
+)
+
+func (e *ArrayEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = ArrayEnum(s)
+	case string:
+		*e = ArrayEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for ArrayEnum: %T", src)
+	}
+	return nil
+}
+
+type NullArrayEnum struct {
+	ArrayEnum ArrayEnum
+	Valid     bool // Valid is true if ArrayEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullArrayEnum) Scan(value any) error {
+	if value == nil {
+		ns.ArrayEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ArrayEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullArrayEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.ArrayEnum), nil
+}
+
+type QueryParamEnumTableEnum string
+
+const (
+	QueryParamEnumTableEnumG QueryParamEnumTableEnum = "g"
+	QueryParamEnumTableEnumH QueryParamEnumTableEnum = "h"
+)
+
+func (e *QueryParamEnumTableEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QueryParamEnumTableEnum(s)
+	case string:
+		*e = QueryParamEnumTableEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QueryParamEnumTableEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQueryParamEnumTableEnum struct {
+	QueryParamEnumTableEnum QueryParamEnumTableEnum
+	Valid                   bool // Valid is true if QueryParamEnumTableEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQueryParamEnumTableEnum) Scan(value any) error {
+	if value == nil {
+		ns.QueryParamEnumTableEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QueryParamEnumTableEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQueryParamEnumTableEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QueryParamEnumTableEnum), nil
+}
+
+type QueryParamStructEnumTableEnum string
+
+const (
+	QueryParamStructEnumTableEnumI QueryParamStructEnumTableEnum = "i"
+	QueryParamStructEnumTableEnumJ QueryParamStructEnumTableEnum = "j"
+)
+
+func (e *QueryParamStructEnumTableEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QueryParamStructEnumTableEnum(s)
+	case string:
+		*e = QueryParamStructEnumTableEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QueryParamStructEnumTableEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQueryParamStructEnumTableEnum struct {
+	QueryParamStructEnumTableEnum QueryParamStructEnumTableEnum
+	Valid                         bool // Valid is true if QueryParamStructEnumTableEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQueryParamStructEnumTableEnum) Scan(value any) error {
+	if value == nil {
+		ns.QueryParamStructEnumTableEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QueryParamStructEnumTableEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQueryParamStructEnumTableEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QueryParamStructEnumTableEnum), nil
+}
+
+type QueryReturnEnumTableEnum string
+
+const (
+	QueryReturnEnumTableEnumK QueryReturnEnumTableEnum = "k"
+	QueryReturnEnumTableEnumL QueryReturnEnumTableEnum = "l"
+)
+
+func (e *QueryReturnEnumTableEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QueryReturnEnumTableEnum(s)
+	case string:
+		*e = QueryReturnEnumTableEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QueryReturnEnumTableEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQueryReturnEnumTableEnum struct {
+	QueryReturnEnumTableEnum QueryReturnEnumTableEnum
+	Valid                    bool // Valid is true if QueryReturnEnumTableEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQueryReturnEnumTableEnum) Scan(value any) error {
+	if value == nil {
+		ns.QueryReturnEnumTableEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QueryReturnEnumTableEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQueryReturnEnumTableEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QueryReturnEnumTableEnum), nil
+}
+
+type QueryReturnFullTableEnum string
+
+const (
+	QueryReturnFullTableEnumE QueryReturnFullTableEnum = "e"
+	QueryReturnFullTableEnumF QueryReturnFullTableEnum = "f"
+)
+
+func (e *QueryReturnFullTableEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QueryReturnFullTableEnum(s)
+	case string:
+		*e = QueryReturnFullTableEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QueryReturnFullTableEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQueryReturnFullTableEnum struct {
+	QueryReturnFullTableEnum QueryReturnFullTableEnum
+	Valid                    bool // Valid is true if QueryReturnFullTableEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQueryReturnFullTableEnum) Scan(value any) error {
+	if value == nil {
+		ns.QueryReturnFullTableEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QueryReturnFullTableEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQueryReturnFullTableEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QueryReturnFullTableEnum), nil
+}
+
+type QueryReturnStructEnumTableEnum string
+
+const (
+	QueryReturnStructEnumTableEnumK QueryReturnStructEnumTableEnum = "k"
+	QueryReturnStructEnumTableEnumL QueryReturnStructEnumTableEnum = "l"
+)
+
+func (e *QueryReturnStructEnumTableEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QueryReturnStructEnumTableEnum(s)
+	case string:
+		*e = QueryReturnStructEnumTableEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QueryReturnStructEnumTableEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQueryReturnStructEnumTableEnum struct {
+	QueryReturnStructEnumTableEnum QueryReturnStructEnumTableEnum
+	Valid                          bool // Valid is true if QueryReturnStructEnumTableEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQueryReturnStructEnumTableEnum) Scan(value any) error {
+	if value == nil {
+		ns.QueryReturnStructEnumTableEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QueryReturnStructEnumTableEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQueryReturnStructEnumTableEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QueryReturnStructEnumTableEnum), nil
+}
+
+type QuerySqlcEmbedEnum string
+
+const (
+	QuerySqlcEmbedEnumM QuerySqlcEmbedEnum = "m"
+	QuerySqlcEmbedEnumN QuerySqlcEmbedEnum = "n"
+)
+
+func (e *QuerySqlcEmbedEnum) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = QuerySqlcEmbedEnum(s)
+	case string:
+		*e = QuerySqlcEmbedEnum(s)
+	default:
+		return fmt.Errorf("unsupported scan type for QuerySqlcEmbedEnum: %T", src)
+	}
+	return nil
+}
+
+type NullQuerySqlcEmbedEnum struct {
+	QuerySqlcEmbedEnum QuerySqlcEmbedEnum
+	Valid              bool // Valid is true if QuerySqlcEmbedEnum is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullQuerySqlcEmbedEnum) Scan(value any) error {
+	if value == nil {
+		ns.QuerySqlcEmbedEnum, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.QuerySqlcEmbedEnum.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullQuerySqlcEmbedEnum) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.QuerySqlcEmbedEnum), nil
+}
+
+type ArrayEnumTable struct {
+	ID    int32
+	Value []ArrayEnum
+}
+
+type QueryParamEnumTable struct {
+	ID    int32
+	Other QueryParamEnumTableEnum
+	Value NullQueryParamEnumTableEnum
+}
+
+type QueryReturnFullTable struct {
+	ID    int32
+	Value NullQueryReturnFullTableEnum
+}
+
+type QuerySqlcEmbedTable struct {
+	ID    int32
+	Value NullQuerySqlcEmbedEnum
+}

internal/endtoend/testdata/omit_unused_structs/postgresql/stdlib/go/query.sql.go

@@ -0,0 +1,136 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: query.sql
+
+package db
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/lib/pq"
+)
+
+const query_enum_array_table = `-- name: query_enum_array_table :many
+SELECT id, value FROM array_enum_table
+`
+
+func (q *Queries) query_enum_array_table(ctx context.Context) ([]ArrayEnumTable, error) {
+	rows, err := q.db.QueryContext(ctx, query_enum_array_table)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []ArrayEnumTable
+	for rows.Next() {
+		var i ArrayEnumTable
+		if err := rows.Scan(&i.ID, pq.Array(&i.Value)); 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 query_param_enum_table = `-- name: query_param_enum_table :one
+SELECT id, other, value FROM query_param_enum_table WHERE value = $1
+`
+
+func (q *Queries) query_param_enum_table(ctx context.Context, value NullQueryParamEnumTableEnum) (QueryParamEnumTable, error) {
+	row := q.db.QueryRowContext(ctx, query_param_enum_table, value)
+	var i QueryParamEnumTable
+	err := row.Scan(&i.ID, &i.Other, &i.Value)
+	return i, err
+}
+
+const query_param_struct_enum_table = `-- name: query_param_struct_enum_table :one
+SELECT id FROM query_param_struct_enum_table WHERE id = $1 AND value = $2
+`
+
+type query_param_struct_enum_tableParams struct {
+	ID    int32
+	Value NullQueryParamStructEnumTableEnum
+}
+
+func (q *Queries) query_param_struct_enum_table(ctx context.Context, arg query_param_struct_enum_tableParams) (int32, error) {
+	row := q.db.QueryRowContext(ctx, query_param_struct_enum_table, arg.ID, arg.Value)
+	var id int32
+	err := row.Scan(&id)
+	return id, err
+}
+
+const query_return_enum_table = `-- name: query_return_enum_table :one
+SELECT value FROM query_return_enum_table WHERE id = $1
+`
+
+func (q *Queries) query_return_enum_table(ctx context.Context, id int32) (NullQueryReturnEnumTableEnum, error) {
+	row := q.db.QueryRowContext(ctx, query_return_enum_table, id)
+	var value NullQueryReturnEnumTableEnum
+	err := row.Scan(&value)
+	return value, err
+}
+
+const query_return_full_table = `-- name: query_return_full_table :many
+SELECT id, value FROM query_return_full_table
+`
+
+func (q *Queries) query_return_full_table(ctx context.Context) ([]QueryReturnFullTable, error) {
+	rows, err := q.db.QueryContext(ctx, query_return_full_table)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []QueryReturnFullTable
+	for rows.Next() {
+		var i QueryReturnFullTable
+		if err := rows.Scan(&i.ID, &i.Value); 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 query_return_struct_enum_table = `-- name: query_return_struct_enum_table :one
+SELECT value, another FROM query_return_struct_enum_table WHERE id = $1
+`
+
+type query_return_struct_enum_tableRow struct {
+	Value   NullQueryReturnStructEnumTableEnum
+	Another sql.NullInt32
+}
+
+func (q *Queries) query_return_struct_enum_table(ctx context.Context, id int32) (query_return_struct_enum_tableRow, error) {
+	row := q.db.QueryRowContext(ctx, query_return_struct_enum_table, id)
+	var i query_return_struct_enum_tableRow
+	err := row.Scan(&i.Value, &i.Another)
+	return i, err
+}
+
+const query_sqlc_embed_table = `-- name: query_sqlc_embed_table :one
+SELECT query_sqlc_embed_table.id, query_sqlc_embed_table.value FROM query_sqlc_embed_table WHERE id = $1
+`
+
+type query_sqlc_embed_tableRow struct {
+	QuerySqlcEmbedTable QuerySqlcEmbedTable
+}
+
+func (q *Queries) query_sqlc_embed_table(ctx context.Context, id int32) (query_sqlc_embed_tableRow, error) {
+	row := q.db.QueryRowContext(ctx, query_sqlc_embed_table, id)
+	var i query_sqlc_embed_tableRow
+	err := row.Scan(&i.QuerySqlcEmbedTable.ID, &i.QuerySqlcEmbedTable.Value)
+	return i, err
+}