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

internal/codegen/golang/templates/go-sql-driver-mysql/copyfromCopy.tmpl

@@ -0,0 +1,52 @@
+{{define "copyfromCodeGoSqlDriver"}}
+{{range .GoQueries}}
+{{if eq .Cmd ":copyfrom" }}
+var readerHandlerSequenceFor{{.MethodName}} uint32 = 1
+
+func convertRowsFor{{.MethodName}}(w *io.PipeWriter, {{.Arg.SlicePair}}) {
+	e := mysqltsv.NewEncoder(w, {{ len .Arg.CopyFromMySQLFields }}, nil)
+	for _, row := range {{.Arg.Name}} {
+{{- with $arg := .Arg }}
+{{- range $arg.CopyFromMySQLFields}}
+{{- if eq .Type "string"}}
+	e.AppendString({{if $arg.Struct}}row.{{.Name}}{{else}}row{{end}})
+{{- else if or (eq .Type "[]byte") (eq .Type "json.RawMessage")}}
+	e.AppendBytes({{if $arg.Struct}}row.{{.Name}}{{else}}row{{end}})
+{{- else}}
+	e.AppendValue({{if $arg.Struct}}row.{{.Name}}{{else}}row{{end}})
+{{- end}}
+{{- end}}
+{{- end}}
+	}
+	w.CloseWithError(e.Close())
+}
+
+{{range .Comments}}//{{.}}
+{{end -}}
+// {{.MethodName}} uses MySQL's LOAD DATA LOCAL INFILE and is not atomic.
+//
+// Errors and duplicate keys are treated as warnings and insertion will
+// continue, even without an error for some cases.  Use this in a transaction
+// and use SHOW WARNINGS to check for any problems and roll back if you want to.
+//
+// Check the documentation for more information:
+// https://dev.mysql.com/doc/refman/8.0/en/load-data.html#load-data-error-handling
+func (q *Queries) {{.MethodName}}(ctx context.Context{{if $.EmitMethodsWithDBArgument}}, db DBTX{{end}}, {{.Arg.SlicePair}}) (int64, error) {
+	pr, pw := io.Pipe()
+	defer pr.Close()
+	rh := fmt.Sprintf("{{.MethodName}}_%d", atomic.AddUint32(&readerHandlerSequenceFor{{.MethodName}}, 1))
+	mysql.RegisterReaderHandler(rh, func() io.Reader { return pr })
+	defer mysql.DeregisterReaderHandler(rh)
+	go convertRowsFor{{.MethodName}}(pw, {{.Arg.Name}})
+	// The string interpolation is necessary because LOAD DATA INFILE requires
+	// the file name to be given as a literal string.
+	result, err := {{if (not $.EmitMethodsWithDBArgument)}}q.{{end}}db.ExecContext(ctx, fmt.Sprintf("LOAD DATA LOCAL INFILE '%s' INTO TABLE {{.TableIdentifierForMySQL}} %s ({{range $index, $name := .Arg.ColumnNames}}{{if gt $index 0}}, {{end}}{{$name}}{{end}})", "Reader::" + rh, mysqltsv.Escaping))
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}
+
+{{end}}
+{{end}}
+{{end}}

internal/codegen/golang/templates/pgx/batchCode.tmpl

@@ -0,0 +1,134 @@
+{{define "batchCodePgx"}}
+
+var (
+	ErrBatchAlreadyClosed = errors.New("batch already closed")
+)
+
+{{range .GoQueries}}
+{{if eq (hasPrefix .Cmd ":batch") true }}
+const {{.ConstantName}} = {{$.Q}}-- name: {{.MethodName}} {{.Cmd}}
+{{escape .SQL}}
+{{$.Q}}
+
+type {{.MethodName}}BatchResults struct {
+    br pgx.BatchResults
+    tot int
+    closed bool
+}
+
+{{if .Arg.Struct}}
+type {{.Arg.Type}} struct { {{- range .Arg.Struct.Fields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+
+{{if .Ret.EmitStruct}}
+type {{.Ret.Type}} struct { {{- range .Ret.Struct.Fields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ if $.EmitMethodsWithDBArgument}}db DBTX,{{end}} {{.Arg.SlicePair}}) *{{.MethodName}}BatchResults {
+    batch := &pgx.Batch{}
+    for _, a := range {{index .Arg.Name}} {
+        vals := []any{
+        {{- if .Arg.Struct }}
+        {{- range .Arg.Struct.Fields }}
+            a.{{.Name}},
+        {{- end }}
+        {{- else }}
+            a,
+        {{- end }}
+        }
+        batch.Queue({{.ConstantName}}, vals...)
+    }
+    br := {{if not $.EmitMethodsWithDBArgument}}q.{{end}}db.SendBatch(ctx, batch)
+    return &{{.MethodName}}BatchResults{br,len({{.Arg.Name}}),false}
+}
+
+{{if eq .Cmd ":batchexec"}}
+func (b *{{.MethodName}}BatchResults) Exec(f func(int, error)) {
+	defer b.br.Close()
+   for t := 0; t < b.tot; t++ {
+     if b.closed {
+       if f != nil {
+         f(t, ErrBatchAlreadyClosed)
+       }
+       continue
+     }
+     _, err := b.br.Exec()
+     if f != nil {
+        f(t, err)
+     }
+   }
+}
+{{end}}
+
+{{if eq .Cmd ":batchmany"}}
+func (b *{{.MethodName}}BatchResults) Query(f func(int, []{{.Ret.DefineType}}, error)) {
+	defer b.br.Close()
+   for t := 0; t < b.tot; t++ {
+     {{- if $.EmitEmptySlices}}
+     items := []{{.Ret.DefineType}}{}
+     {{else}}
+     var items []{{.Ret.DefineType}}
+     {{end -}}
+     if b.closed {
+        if f != nil {
+          f(t, items, ErrBatchAlreadyClosed)
+        }
+        continue
+     }
+     err := func() error {
+       rows, err := b.br.Query()
+       if err != nil {
+         return err
+       }
+       defer rows.Close()
+       for rows.Next() {
+           var {{.Ret.Name}} {{.Ret.Type}}
+           if err := rows.Scan({{.Ret.Scan}}); err != nil {
+             return err
+           }
+           items = append(items, {{.Ret.ReturnName}})
+        }
+        return rows.Err()
+      }()
+      if f != nil {
+        f(t, items, err)
+      }
+   }
+}
+{{end}}
+
+{{if eq .Cmd ":batchone"}}
+func (b *{{.MethodName}}BatchResults) QueryRow(f func(int, {{.Ret.DefineType}}, error)) {
+	defer b.br.Close()
+   for t := 0; t < b.tot; t++ {
+     var {{.Ret.Name}} {{.Ret.Type}}
+     if b.closed {
+        if f != nil {
+          f(t, {{if .Ret.IsPointer}}nil{{else}}{{.Ret.Name}}{{end}}, ErrBatchAlreadyClosed)
+        }
+        continue
+     }
+     row := b.br.QueryRow()
+	  err := row.Scan({{.Ret.Scan}})
+     if f != nil {
+       f(t, {{.Ret.ReturnName}}, err)
+     }
+   }
+}
+{{end}}
+
+func (b *{{.MethodName}}BatchResults) Close() error {
+    b.closed = true
+    return b.br.Close()
+}
+{{end}}
+{{end}}
+{{end}}

internal/codegen/golang/templates/pgx/copyfromCopy.tmpl

@@ -0,0 +1,51 @@
+{{define "copyfromCodePgx"}}
+{{range .GoQueries}}
+{{if eq .Cmd ":copyfrom" }}
+// iteratorFor{{.MethodName}} implements pgx.CopyFromSource.
+type iteratorFor{{.MethodName}} struct {
+	rows []{{.Arg.DefineType}}
+	skippedFirstNextCall bool
+}
+
+func (r *iteratorFor{{.MethodName}}) Next() bool {
+	if len(r.rows) == 0 {
+		return false
+	}
+	if !r.skippedFirstNextCall {
+		r.skippedFirstNextCall = true
+		return true
+	}
+	r.rows = r.rows[1:]
+	return len(r.rows) > 0
+}
+
+func (r iteratorFor{{.MethodName}}) Values() ([]any, error) {
+	return []any{
+{{- if .Arg.Struct }}
+{{- range .Arg.Struct.Fields }}
+		r.rows[0].{{.Name}},
+{{- end }}
+{{- else }}
+		r.rows[0],
+{{- end }}
+	}, nil
+}
+
+func (r iteratorFor{{.MethodName}}) Err() error {
+	return nil
+}
+
+{{range .Comments}}//{{.}}
+{{end -}}
+{{- if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.SlicePair}}) (int64, error) {
+	return db.CopyFrom(ctx, {{.TableIdentifierAsGoSlice}}, {{.Arg.ColumnNamesAsGoSlice}}, &iteratorFor{{.MethodName}}{rows: {{.Arg.Name}}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.SlicePair}}) (int64, error) {
+	return q.db.CopyFrom(ctx, {{.TableIdentifierAsGoSlice}}, {{.Arg.ColumnNamesAsGoSlice}}, &iteratorFor{{.MethodName}}{rows: {{.Arg.Name}}})
+{{- end}}
+}
+
+{{end}}
+{{end}}
+{{end}}

internal/codegen/golang/templates/pgx/dbCode.tmpl

@@ -0,0 +1,37 @@
+{{define "dbCodeTemplatePgx"}}
+
+type DBTX interface {
+	Exec(context.Context, string, ...any) (pgconn.CommandTag, error)
+	Query(context.Context, string, ...any) (pgx.Rows, error)
+	QueryRow(context.Context, string, ...any) pgx.Row
+{{- if .UsesCopyFrom }}
+	CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error)
+{{- end }}
+{{- if .UsesBatch }}
+	SendBatch(context.Context, *pgx.Batch) pgx.BatchResults
+{{- end }}
+}
+
+{{ if .EmitMethodsWithDBArgument}}
+func New() *Queries {
+	return &Queries{}
+{{- else -}}
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+{{- end}}
+}
+
+type Queries struct {
+    {{if not .EmitMethodsWithDBArgument}}
+	db DBTX
+    {{end}}
+}
+
+{{if not .EmitMethodsWithDBArgument}}
+func (q *Queries) WithTx(tx pgx.Tx) *Queries {
+	return &Queries{
+		db: tx,
+	}
+}
+{{end}}
+{{end}}

internal/codegen/golang/templates/pgx/interfaceCode.tmpl

@@ -0,0 +1,73 @@
+{{define "interfaceCodePgx"}}
+    type Querier interface {
+    {{- $dbtxParam := .EmitMethodsWithDBArgument -}}
+    {{- range .GoQueries}}
+        {{- if and (eq .Cmd ":one") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error)
+        {{- else if eq .Cmd ":one" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":many") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error)
+        {{- else if eq .Cmd ":many" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":exec") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) error
+        {{- else if eq .Cmd ":exec" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) error
+        {{- end}}
+        {{- if and (eq .Cmd ":execrows") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (int64, error)
+        {{- else if eq .Cmd ":execrows" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (int64, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":execresult") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (pgconn.CommandTag, error)
+        {{- else if eq .Cmd ":execresult" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (pgconn.CommandTag, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":copyfrom") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.SlicePair}}) (int64, error)
+        {{- else if eq .Cmd ":copyfrom" }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.SlicePair}}) (int64, error)
+        {{- end}}
+        {{- if and (or (eq .Cmd ":batchexec") (eq .Cmd ":batchmany") (eq .Cmd ":batchone")) ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.SlicePair}}) *{{.MethodName}}BatchResults
+        {{- else if or (eq .Cmd ":batchexec") (eq .Cmd ":batchmany") (eq .Cmd ":batchone") }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.SlicePair}}) *{{.MethodName}}BatchResults
+        {{- end}}
+
+    {{- end}}
+    }
+
+    var _ Querier = (*Queries)(nil)
+{{end}}

internal/codegen/golang/templates/pgx/queryCode.tmpl

@@ -0,0 +1,142 @@
+{{define "queryCodePgx"}}
+{{range .GoQueries}}
+{{if $.OutputQuery .SourceName}}
+{{if and (ne .Cmd ":copyfrom") (ne (hasPrefix .Cmd ":batch") true)}}
+const {{.ConstantName}} = {{$.Q}}-- name: {{.MethodName}} {{.Cmd}}
+{{escape .SQL}}
+{{$.Q}}
+{{end}}
+
+{{if ne (hasPrefix .Cmd ":batch") true}}
+{{if .Arg.EmitStruct}}
+type {{.Arg.Type}} struct { {{- range .Arg.Struct.Fields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+
+{{if .Ret.EmitStruct}}
+type {{.Ret.Type}} struct { {{- range .Ret.Struct.Fields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+{{end}}
+
+{{if eq .Cmd ":one"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+{{- if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error) {
+	row := db.QueryRow(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error) {
+	row := q.db.QueryRow(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- end}}
+	{{- if or (ne .Arg.Pair .Ret.Pair) (ne .Arg.DefineType .Ret.DefineType) }}
+	var {{.Ret.Name}} {{.Ret.Type}}
+	{{- end}}
+	err := row.Scan({{.Ret.Scan}})
+	{{- if $.WrapErrors}}
+	if err != nil {
+		err = fmt.Errorf("query {{.MethodName}}: %w", err)
+	}
+	{{- end}}
+	return {{.Ret.ReturnName}}, err
+}
+{{end}}
+
+{{if eq .Cmd ":many"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+{{- if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error) {
+	rows, err := db.Query(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error) {
+	rows, err := q.db.Query(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- end}}
+	if err != nil {
+		return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+	}
+	defer rows.Close()
+	{{- if $.EmitEmptySlices}}
+	items := []{{.Ret.DefineType}}{}
+	{{else}}
+	var items []{{.Ret.DefineType}}
+	{{end -}}
+	for rows.Next() {
+		var {{.Ret.Name}} {{.Ret.Type}}
+		if err := rows.Scan({{.Ret.Scan}}); err != nil {
+			return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+		}
+		items = append(items, {{.Ret.ReturnName}})
+	}
+	if err := rows.Err(); err != nil {
+		return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+	}
+	return items, nil
+}
+{{end}}
+
+{{if eq .Cmd ":exec"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+{{- if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) error {
+	_, err := db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) error {
+	_, err := q.db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- end}}
+	{{- if $.WrapErrors }}
+	if err != nil {
+		return fmt.Errorf("query {{.MethodName}}: %w", err)
+	}
+	return nil
+	{{- else }}
+	return err
+	{{- end }}
+}
+{{end}}
+
+{{if eq .Cmd ":execrows"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+{{if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (int64, error) {
+	result, err := db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (int64, error) {
+	result, err := q.db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- end}}
+	if err != nil {
+		return 0, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+	}
+	return result.RowsAffected(), nil
+}
+{{end}}
+
+{{if eq .Cmd ":execresult"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+{{- if $.EmitMethodsWithDBArgument -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (pgconn.CommandTag, error) {
+	{{queryRetval .}} db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- else -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (pgconn.CommandTag, error) {
+	{{queryRetval .}} q.db.Exec(ctx, {{.ConstantName}}, {{.Arg.Params}})
+{{- end}}
+	{{- if $.WrapErrors}}
+	if err != nil {
+		err = fmt.Errorf("query {{.MethodName}}: %w", err)
+	}
+	return result, err
+	{{- end}}
+}
+{{end}}
+
+
+{{end}}
+{{end}}
+{{end}}

internal/codegen/golang/templates/stdlib/dbCode.tmpl

@@ -0,0 +1,105 @@
+{{define "dbCodeTemplateStd"}}
+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
+}
+
+{{ if .EmitMethodsWithDBArgument}}
+func New() *Queries {
+	return &Queries{}
+{{- else -}}
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+{{- end}}
+}
+
+{{if .EmitPreparedQueries}}
+func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
+	q := Queries{db: db}
+	var err error
+	{{- if eq (len .GoQueries) 0 }}
+	_ = err
+	{{- end }}
+	{{- range .GoQueries }}
+	if q.{{.FieldName}}, err = db.PrepareContext(ctx, {{.ConstantName}}); err != nil {
+		return nil, fmt.Errorf("error preparing query {{.MethodName}}: %w", err)
+	}
+	{{- end}}
+	return &q, nil
+}
+
+func (q *Queries) Close() error {
+	var err error
+	{{- range .GoQueries }}
+	if q.{{.FieldName}} != nil {
+		if cerr := q.{{.FieldName}}.Close(); cerr != nil {
+			err = fmt.Errorf("error closing {{.FieldName}}: %w", cerr)
+		}
+	}
+	{{- end}}
+	return err
+}
+
+func (q *Queries) exec(ctx context.Context, stmt *sql.Stmt, query string, args ...any) (sql.Result, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).ExecContext(ctx, args...)
+	case stmt != nil:
+		return stmt.ExecContext(ctx, args...)
+	default:
+		return q.db.ExecContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) query(ctx context.Context, stmt *sql.Stmt, query string, args ...any) (*sql.Rows, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryContext(ctx, args...)
+	default:
+		return q.db.QueryContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, args ...any) (*sql.Row) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryRowContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryRowContext(ctx, args...)
+	default:
+		return q.db.QueryRowContext(ctx, query, args...)
+	}
+}
+{{end}}
+
+type Queries struct {
+    {{- if not .EmitMethodsWithDBArgument}}
+	db DBTX
+    {{- end}}
+
+    {{- if .EmitPreparedQueries}}
+	tx         *sql.Tx
+	{{- range .GoQueries}}
+	{{.FieldName}}  *sql.Stmt
+	{{- end}}
+	{{- end}}
+}
+
+{{if not .EmitMethodsWithDBArgument}}
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db: tx,
+     	{{- if .EmitPreparedQueries}}
+		tx: tx,
+		{{- range .GoQueries}}
+		{{.FieldName}}: q.{{.FieldName}},
+		{{- end}}
+		{{- end}}
+	}
+}
+{{end}}
+{{end}}

internal/codegen/golang/templates/stdlib/interfaceCode.tmpl

@@ -0,0 +1,63 @@
+{{define "interfaceCodeStd"}}
+    type Querier interface {
+    {{- $dbtxParam := .EmitMethodsWithDBArgument -}}
+    {{- range .GoQueries}}
+        {{- if and (eq .Cmd ":one") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error)
+        {{- else if eq .Cmd ":one"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ({{.Ret.DefineType}}, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":many") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error)
+        {{- else if eq .Cmd ":many"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":exec") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) error
+        {{- else if eq .Cmd ":exec"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) error
+        {{- end}}
+        {{- if and (eq .Cmd ":execrows") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (int64, error)
+        {{- else if eq .Cmd ":execrows"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (int64, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":execlastid") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (int64, error)
+        {{- else if eq .Cmd ":execlastid"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (int64, error)
+        {{- end}}
+        {{- if and (eq .Cmd ":execresult") ($dbtxParam) }}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, db DBTX, {{.Arg.Pair}}) (sql.Result, error)
+        {{- else if eq .Cmd ":execresult"}}
+            {{range .Comments}}//{{.}}
+            {{end -}}
+            {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) (sql.Result, error)
+        {{- end}}
+    {{- end}}
+    }
+
+    var _ Querier = (*Queries)(nil)
+{{end}}

internal/codegen/golang/templates/stdlib/queryCode.tmpl

@@ -0,0 +1,171 @@
+{{define "queryCodeStd"}}
+{{range .GoQueries}}
+{{if $.OutputQuery .SourceName}}
+const {{.ConstantName}} = {{$.Q}}-- name: {{.MethodName}} {{.Cmd}}
+{{escape .SQL}}
+{{$.Q}}
+
+{{if .Arg.EmitStruct}}
+type {{.Arg.Type}} struct { {{- range .Arg.UniqueFields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+
+{{if .Ret.EmitStruct}}
+type {{.Ret.Type}} struct { {{- range .Ret.Struct.Fields}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+
+{{if eq .Cmd ":one"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) ({{.Ret.DefineType}}, error) {
+    {{- template "queryCodeStdExec" . }}
+	{{- if or (ne .Arg.Pair .Ret.Pair) (ne .Arg.DefineType .Ret.DefineType) }}
+	var {{.Ret.Name}} {{.Ret.Type}}
+	{{- end}}
+	err := row.Scan({{.Ret.Scan}})
+	{{- if $.WrapErrors}}
+	if err != nil {
+		err = fmt.Errorf("query {{.MethodName}}: %w", err)
+	}
+	{{- end}}
+	return {{.Ret.ReturnName}}, err
+}
+{{end}}
+
+{{if eq .Cmd ":many"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) ([]{{.Ret.DefineType}}, error) {
+    {{- template "queryCodeStdExec" . }}
+    if err != nil {
+        return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+    }
+    defer rows.Close()
+    {{- if $.EmitEmptySlices}}
+    items := []{{.Ret.DefineType}}{}
+    {{else}}
+    var items []{{.Ret.DefineType}}
+    {{end -}}
+    for rows.Next() {
+        var {{.Ret.Name}} {{.Ret.Type}}
+        if err := rows.Scan({{.Ret.Scan}}); err != nil {
+            return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+        }
+        items = append(items, {{.Ret.ReturnName}})
+    }
+    if err := rows.Close(); err != nil {
+        return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+    }
+    if err := rows.Err(); err != nil {
+        return nil, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+    }
+    return items, nil
+}
+{{end}}
+
+{{if eq .Cmd ":exec"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) error {
+    {{- template "queryCodeStdExec" . }}
+    {{- if $.WrapErrors}}
+    if err != nil {
+        err = fmt.Errorf("query {{.MethodName}}: %w", err)
+    }
+    {{- end}}
+    return err
+}
+{{end}}
+
+{{if eq .Cmd ":execrows"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) (int64, error) {
+    {{- template "queryCodeStdExec" . }}
+    if err != nil {
+        return 0, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+    }
+    return result.RowsAffected()
+}
+{{end}}
+
+{{if eq .Cmd ":execlastid"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) (int64, error) {
+    {{- template "queryCodeStdExec" . }}
+    if err != nil {
+        return 0, {{if $.WrapErrors}}fmt.Errorf("query {{.MethodName}}: %w", err){{else}}err{{end}}
+    }
+    return result.LastInsertId()
+}
+{{end}}
+
+{{if eq .Cmd ":execresult"}}
+{{range .Comments}}//{{.}}
+{{end -}}
+func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}) (sql.Result, error) {
+    {{- template "queryCodeStdExec" . }}
+    {{- if $.WrapErrors}}
+    if err != nil {
+        err = fmt.Errorf("query {{.MethodName}}: %w", err)
+    }
+    return result, err
+    {{- end}}
+}
+{{end}}
+
+{{end}}
+{{end}}
+{{end}}
+
+{{define "queryCodeStdExec"}}
+    {{- if .Arg.HasSqlcSlices }}
+        query := {{.ConstantName}}
+        var queryParams []any
+        {{- if .Arg.Struct }}
+            {{- $arg := .Arg }}
+            {{- range .Arg.Struct.Fields }}
+                {{- if .HasSqlcSlice }}
+                    if len({{$arg.VariableForField .}}) > 0 {
+                      for _, v := range {{$arg.VariableForField .}} {
+                        queryParams = append(queryParams, v)
+                      }
+                      query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/?", strings.Repeat(",?", len({{$arg.VariableForField .}}))[1:], 1)
+                    } else {
+                      query = strings.Replace(query, "/*SLICE:{{.Column.Name}}*/?", "NULL", 1)
+                    }
+                {{- else }}
+                  queryParams = append(queryParams, {{$arg.VariableForField .}})
+                {{- end }}
+            {{- end }}
+        {{- else }}
+            {{- /* Single argument parameter to this goroutine (they are not packed
+                in a struct), because .Arg.HasSqlcSlices further up above was true,
+                this section is 100% a slice (impossible to get here otherwise).
+            */}}
+            if len({{.Arg.Name}}) > 0 {
+              for _, v := range {{.Arg.Name}} {
+                queryParams = append(queryParams, v)
+              }
+              query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/?", strings.Repeat(",?", len({{.Arg.Name}}))[1:], 1)
+            } else {
+              query = strings.Replace(query, "/*SLICE:{{.Arg.Column.Name}}*/?", "NULL", 1)
+            }
+        {{- end }}
+        {{- if emitPreparedQueries }}
+        {{ queryRetval . }} {{ queryMethod . }}(ctx, nil, query, queryParams...)
+        {{- else}}
+        {{ queryRetval . }} {{ queryMethod . }}(ctx, query, queryParams...)
+        {{- end -}}
+    {{- else if emitPreparedQueries }}
+        {{- queryRetval . }} {{ queryMethod . }}(ctx, q.{{.FieldName}}, {{.ConstantName}}, {{.Arg.Params}})
+    {{- else}}
+        {{- queryRetval . }} {{ queryMethod . }}(ctx, {{.ConstantName}}, {{.Arg.Params}})
+    {{- end -}}
+{{end}}

internal/codegen/golang/templates/template.tmpl

@@ -0,0 +1,254 @@
+{{define "dbFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}
+
+package {{.Package}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "dbCode" . }}
+{{end}}
+
+{{define "dbCode"}}
+
+{{if .SQLDriver.IsPGX }}
+	{{- template "dbCodeTemplatePgx" .}}
+{{else}}
+	{{- template "dbCodeTemplateStd" .}}
+{{end}}
+
+{{end}}
+
+{{define "interfaceFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}
+
+package {{.Package}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "interfaceCode" . }}
+{{end}}
+
+{{define "interfaceCode"}}
+	{{if .SQLDriver.IsPGX }}
+		{{- template "interfaceCodePgx" .}}
+	{{else}}
+		{{- template "interfaceCodeStd" .}}
+	{{end}}
+{{end}}
+
+{{define "modelsFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}
+
+package {{.ModelsPackage}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "modelsCode" . }}
+{{end}}
+
+{{define "modelsCode"}}
+{{range .Enums}}
+{{if .Comment}}{{comment .Comment}}{{end}}
+type {{.Name}} string
+
+const (
+	{{- range .Constants}}
+	{{.Name}} {{.Type}} = "{{.Value}}"
+	{{- end}}
+)
+
+func (e *{{.Name}}) Scan(src any) error {
+	switch s := src.(type) {
+	case []byte:
+		*e = {{.Name}}(s)
+	case string:
+		*e = {{.Name}}(s)
+	default:
+		return fmt.Errorf("unsupported scan type for {{.Name}}: %T", src)
+	}
+	return nil
+}
+
+type Null{{.Name}} struct {
+	{{.Name}} {{.Name}} {{if .NameTag}}{{$.Q}}{{.NameTag}}{{$.Q}}{{end}}
+  Valid  bool {{if .ValidTag}}{{$.Q}}{{.ValidTag}}{{$.Q}}{{end}} // Valid is true if {{.Name}} is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *Null{{.Name}}) Scan(value any) error {
+	if value == nil {
+		ns.{{.Name}}, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.{{.Name}}.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns Null{{.Name}}) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return string(ns.{{.Name}}), nil
+}
+
+
+{{ if $.EmitEnumValidMethod }}
+func (e {{.Name}}) Valid() bool {
+  switch e {
+  case {{ range $idx, $name := .Constants }}{{ if ne $idx 0 }},{{ "\n" }}{{ end }}{{ .Name }}{{ end }}:
+    return true
+  }
+  return false
+}
+{{ end }}
+
+{{ if $.EmitAllEnumValues }}
+func All{{ .Name }}Values() []{{ .Name }} {
+	return []{{ .Name }}{ {{ range .Constants}}{{ "\n" }}{{ .Name }},{{ end }}
+	}
+}
+{{ end }}
+{{end}}
+
+{{range .Structs}}
+{{if .Comment}}{{comment .Comment}}{{end}}
+type {{.Name}} struct { {{- range .Fields}}
+  {{- if .Comment}}
+  {{comment .Comment}}{{else}}
+  {{- end}}
+  {{.Name}} {{.Type}} {{if .Tag}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
+  {{- end}}
+}
+{{end}}
+{{end}}
+
+{{define "queryFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}// source: {{.SourceName}}
+
+package {{.Package}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "queryCode" . }}
+{{end}}
+
+{{define "queryCode"}}
+{{if .SQLDriver.IsPGX }}
+    {{- template "queryCodePgx" .}}
+{{else}}
+    {{- template "queryCodeStd" .}}
+{{end}}
+{{end}}
+
+{{define "copyfromFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}// source: {{.SourceName}}
+
+package {{.Package}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "copyfromCode" . }}
+{{end}}
+
+{{define "copyfromCode"}}
+{{if .SQLDriver.IsPGX }}
+    {{- template "copyfromCodePgx" .}}
+{{else if .SQLDriver.IsGoSQLDriverMySQL }}
+    {{- template "copyfromCodeGoSqlDriver" .}}
+{{end}}
+{{end}}
+
+{{define "batchFile"}}
+{{if .BuildTags}}
+//go:build {{.BuildTags}}
+
+{{end}}// Code generated by sqlc. DO NOT EDIT.
+{{if not .OmitSqlcVersion}}// versions:
+//   sqlc {{.SqlcVersion}}
+{{end}}// source: {{.SourceName}}
+
+package {{.Package}}
+
+{{ if hasImports .SourceName }}
+import (
+	{{range imports .SourceName}}
+	{{range .}}{{.}}
+	{{end}}
+	{{end}}
+)
+{{end}}
+
+{{template "batchCode" . }}
+{{end}}
+
+{{define "batchCode"}}
+{{if .SQLDriver.IsPGX }}
+    {{- template "batchCodePgx" .}}
+{{end}}
+{{end}}