upstream-sqlc/internal/codegen/golang/templates/stdlib/queryCode.tmpl

{{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}}