Change emit_query_batch to use destination pointers instead of callbacks

Replace the callback-based Queue* API with destination pointers, similar to
json.Unmarshal. This simplifies caller code by eliminating callback nesting -
callers pass pointers where results should be written, and ExecuteBatch
populates them.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jgiles

docs/reference/config.md

@@ -166,7 +166,7 @@ The `gen` mapping supports the following keys:
   - If true, emit a function per enum type
     that returns all valid enum values.
 - `emit_query_batch`:
-  - If true, generate a `QueryBatch` type with `Queue*` methods that batch multiple different queries into a single round-trip. Uses pgx v5's `QueuedQuery` callback API. Only supported with `sql_package: pgx/v5`. Defaults to `false`.
+  - If true, generate a `QueryBatch` type with `Queue*` methods that batch multiple different queries into a single round-trip. Each `Queue*` method accepts destination pointers where results are written when `ExecuteBatch` is called. Only supported with `sql_package: pgx/v5`. Defaults to `false`.
 - `emit_sql_as_comment`:
   - If true, emits the SQL statement as a code-block comment above the generated function, appending to any existing comments. Defaults to `false`.
 - `build_tags`:
@@ -453,7 +453,7 @@ Each mapping in the `packages` collection has the following keys:
   - If true, emit a function per enum type
     that returns all valid enum values.
 - `emit_query_batch`:
-  - If true, generate a `QueryBatch` type with `Queue*` methods that batch multiple different queries into a single round-trip. Uses pgx v5's `QueuedQuery` callback API. Only supported with `sql_package: pgx/v5`. Defaults to `false`.
+  - If true, generate a `QueryBatch` type with `Queue*` methods that batch multiple different queries into a single round-trip. Each `Queue*` method accepts destination pointers where results are written when `ExecuteBatch` is called. Only supported with `sql_package: pgx/v5`. Defaults to `false`.
 - `build_tags`:
   - If set, add a `//go:build <build_tags>` directive at the beginning of each generated Go file.
 - `json_tags_case_style`:

docs/reference/query-annotations.md

@@ -230,11 +230,11 @@ The `:batchexec`, `:batchmany`, and `:batchone` annotations above batch the
 queries** into a single round-trip, use the `emit_query_batch` configuration
 option instead.
 
-When `emit_query_batch` is enabled, sqlc generates a `QueryBatch` type that
-uses pgx v5's `QueuedQuery` callback API. Each regular query (`:one`, `:many`,
-`:exec`, `:execrows`, `:execresult`) gets a `Queue*` method on `QueryBatch`.
-All queued queries are sent in a single round-trip when `ExecuteBatch` is
-called.
+When `emit_query_batch` is enabled, sqlc generates a `QueryBatch` type with
+`Queue*` methods for each regular query (`:one`, `:many`, `:exec`, `:execrows`,
+`:execresult`). Each `Queue*` method accepts destination pointers where results
+are written when `ExecuteBatch` is called. All queued queries are sent in a
+single round-trip.
 
 __NOTE: This option only works with PostgreSQL using the `pgx/v5` driver and outputting Go code.__
 
@@ -268,23 +268,18 @@ UPDATE users SET name = $1 WHERE id = $2;
 // Generated QueryBatch API:
 batch := db.NewQueryBatch()
 
-batch.QueueGetUser(userID, func(user db.User, found bool) error {
-    if !found {
-        return nil // no row matched
-    }
-    fmt.Println(user.Name)
-    return nil
-})
+var user db.User
+var found bool
+batch.QueueGetUser(userID, &user, &found)
 
-batch.QueueListUsers(func(users []db.User) error {
-    fmt.Println("found", len(users), "users")
-    return nil
-})
+var users []db.User
+batch.QueueListUsers(&users)
 
 batch.QueueUpdateUser(db.UpdateUserParams{Name: "Alice", ID: 1})
 
 // Send all queries in one round-trip:
 err := queries.ExecuteBatch(ctx, batch)
+// user, found, and users are now populated
 ```
 
 The `QueryBatch.Batch` field is exported so you can mix generated `Queue*`

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

@@ -1,10 +1,10 @@
 {{define "queryBatchCodePgx"}}
 
 // QueryBatch allows queuing multiple queries to be executed in a single
-// round-trip using pgx v5's QueuedQuery callback pattern. Each Queue* method
-// calls pgx.Batch.Queue and registers a result callback (QueryRow, Query, or
-// Exec) that is invoked when ExecuteBatch processes the batch results.
-// For :exec queries, no callback is needed - errors propagate via ExecuteBatch.
+// round-trip using pgx v5's batch API. Each Queue* method calls
+// pgx.Batch.Queue and registers a result handler that writes to the provided
+// destination pointer(s) when ExecuteBatch processes the batch results.
+// For :exec queries, no destination is needed - errors propagate via ExecuteBatch.
 //
 // The Batch field is exported to allow interoperability: callers can mix
 // generated Queue* calls with custom pgx batch operations on the same
@@ -29,45 +29,40 @@ func (q *Queries) ExecuteBatch(ctx context.Context, {{if $.EmitMethodsWithDBArgu
 {{if and (ne .Cmd ":copyfrom") (ne (hasPrefix .Cmd ":batch") true)}}
 {{if eq .Cmd ":one"}}
 // Queue{{.MethodName}} queues {{.MethodName}} for batch execution.
-// The callback fn is called when ExecuteBatch is called. The second parameter
-// is false if the row was not found (no error is returned in this case).
-func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}fn func({{.Ret.DefineType}}, bool) error) {
+// The result is written to dest when ExecuteBatch is called.
+// If no row is found, *ok is set to false (no error is returned in this case).
+func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}dest *{{.Ret.DefineType}}, ok *bool) {
 	b.Batch.Queue({{.ConstantName}}, {{.Arg.Params}}).QueryRow(func(row pgx.Row) error {
 		var {{.Ret.Name}} {{.Ret.Type}}
 		err := row.Scan({{.Ret.Scan}})
 		if err != nil {
 			if errors.Is(err, pgx.ErrNoRows) {
-				return fn({{.Ret.ReturnName}}, false)
+				*ok = false
+				return nil
 			}
 			return err
 		}
-		return fn({{.Ret.ReturnName}}, true)
+		*dest = {{.Ret.ReturnName}}
+		*ok = true
+		return nil
 	})
 }
 {{end}}
 
 {{if eq .Cmd ":many"}}
 // Queue{{.MethodName}} queues {{.MethodName}} for batch execution.
-// The callback fn is called with the results when ExecuteBatch is called.
-func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}fn func([]{{.Ret.DefineType}}) error) {
+// The results are appended to *dest when ExecuteBatch is called.
+func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}dest *[]{{.Ret.DefineType}}) {
 	b.Batch.Queue({{.ConstantName}}, {{.Arg.Params}}).Query(func(rows pgx.Rows) error {
 		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 err
 			}
-			items = append(items, {{.Ret.ReturnName}})
+			*dest = append(*dest, {{.Ret.ReturnName}})
 		}
-		if err := rows.Err(); err != nil {
-			return err
-		}
-		return fn(items)
+		return rows.Err()
 	})
 }
 {{end}}
@@ -81,20 +76,22 @@ func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}) {
 
 {{if eq .Cmd ":execrows"}}
 // Queue{{.MethodName}} queues {{.MethodName}} for batch execution.
-// The callback fn is called with the number of rows affected when ExecuteBatch is called.
-func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}fn func(int64) error) {
+// The number of rows affected is written to dest when ExecuteBatch is called.
+func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}dest *int64) {
 	b.Batch.Queue({{.ConstantName}}, {{.Arg.Params}}).Exec(func(ct pgconn.CommandTag) error {
-		return fn(ct.RowsAffected())
+		*dest = ct.RowsAffected()
+		return nil
 	})
 }
 {{end}}
 
 {{if eq .Cmd ":execresult"}}
 // Queue{{.MethodName}} queues {{.MethodName}} for batch execution.
-// The callback fn is called with the command tag when ExecuteBatch is called.
-func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}fn func(pgconn.CommandTag) error) {
+// The command tag is written to dest when ExecuteBatch is called.
+func (b *QueryBatch) Queue{{.MethodName}}({{.Arg.Pair}}{{if .Arg.Pair}}, {{end}}dest *pgconn.CommandTag) {
 	b.Batch.Queue({{.ConstantName}}, {{.Arg.Params}}).Exec(func(ct pgconn.CommandTag) error {
-		return fn(ct)
+		*dest = ct
+		return nil
 	})
 }
 {{end}}