LoadType during AfterConnect fails with context timeout leading to queries failing

[jaltavilla]

Describe the bug
I haven't been able to fully figure out what is happening here, so this will probably be a bit unclear. Sorry. There might even be two issues interacting here.
We setup our pgxpool to have an AfterConnect function. This function calls LoadTypes on the connection to prepare it for use. Frequently LoadTypes is resulting in a context timeout and disconnecting from the postgres server. However, it seems like this doesn't always surface to caller and then leads to queries failing with "failed to deallocate cached statement(s): conn closed".

To Reproduce
Unfortunately, I can't really provide a repro case as it's not deterministic. I was able to get this to trigger while running with the race detector enabled and it didn't detect any issues. I setup pgx with a tracelog.TraceLog at TraceLevel and also enabled tracing of the front end with conn.PgConn().Frontend().Trace. Attached is a log from when this occurred. In prior debugging attempts I examined the context passed to the AfterConnect function. It had ~1m10s left till it timed out and the actual call only took ~63ms before the context timeout occurred.

pgx-trace.log

You can see the first error on line 14659 or by searching for "time="2026-04-29T17:33:47Z" level=error".

Expected behavior
LoadTypes succeeds when there is a connection to the database.
Failures in AfterConnect / LoadType don't result in top level pgx calls such as err := pool.SendBatch(ctx, batch).Close() connection closed error when there is no underlying problems preventing connection.

Actual behavior
Queries return failed to deallocate cached statement(s): conn closed sometimes and some connection attempts fail.

Version

• Go: go version go1.26.2 linux/amd64
• PostgreSQL: PostgreSQL 17.9 (Debian 17.9-1.pgdg13+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 14.2.0-19) 14.2.0, 64-bit
• pgx: github.com/jackc/pgx/v5 v5.9.2

Additional context
The behavior occurs even when run locally. On a single machine there is a primary database and an asynchronous streaming replica. There are two pgbouncer instances running, one for each database. All connections are made through pgbouncer in transaction mode.

The behavior seems somewhat timing dependent. Running go test with -v reduces the frequency with which problems occur. I was only able to get it to occur with pgx logs enabled by logging to memory and then writing it to a file at the end. However, the race detector found no issues.

In pgx 5.8.0, the error in LoadTypes was correctly reported and handled by the pool. The subsequent failures didn't occur. After upgrading to 5.9.2, I don't believe I've seen AfterConnect report LoadTypes failed. However, it may have while running with less verbosity. In 5.9.2 other queries failing trying to deallocate prepared statements on a close connection.

We perform no manual Acquire calls. All queries are through the pool (or a txn from the pool). In the test there are three pool instances. One to the primary, and then for read-only calls one to the primary with default_transaction_read_only set to on and one to the replica.

The pgbouncer logs show the client disconnecting during the query, which matches the context timeout error from pgx.

2026-04-29 17:33:47 UTC [575-3] service_user@pastegres LOG:  could not send data to client: Broken pipe
2026-04-29 17:33:47 UTC [575-4] service_user@pastegres STATEMENT:
        WITH RECURSIVE
        -- find the OIDs in pg_class which match one of the provided type names
 <snip>
2026-04-29 17:33:47 UTC [575-5] service_user@pastegres FATAL:  connection to client lost

While I can't provide the code in full, I can share pieces as relevant as well as logs from postgres. I can also try any suggestions or additional logging to help understand this issue.

Thanks!

[jaltavilla]

I've had a bit of time to investigate this further.

Calling LoadTypes sometimes returns no error, but the underlying connection ends up closed during the call. Since there was no error the pool uses this connection to call BatchSend (or whatever method the calling code was using). One of the first things BatchSend does is attempt to call deallocateInvalidatedCachedStatements. This function doesn't check that the connection is open. Thus callers to pool.BatchSend get the confusing "failed to deallocate cached statement(s): conn closed" message.

These leads to two questions about mitigating the effects of of handling a closed connection:

• Should deallocateInvalidatedCachedStatements do nothing if the connection is closed? Or should it never be called on a closed connection?
• Should pgx check that the connection hasn't been closed before adding it to the pool in creation? Or during acquire (I tried adding a ShouldPing that returns true and it didn't affect this behavior)?

I still don't know what the cause of the LoadTypes behavior. To try and work around this problem, I changed our implementation to check if the connection was closed by LoadTypes and return an error. This generally works, but I think it's only hiding a symptom of some deeper problem. Sometimes with this check, the connection remains open but not all types seem to be added to the typemap by LoadTypes. This manifests as some tests failing with the error: "error preprocessing batch (build): failed to encode args[0]: unable to encode data.Parent{String:"one", Ignored:1, Inner:data.Child{String:"one-inner", Ignored:2, Duration:(*time.Duration)(nil), Unused:map[string]int32{}, Values:[]int32{1, 2, 3}}} into text format for unknown type (OID 16620): cannot find encode plan". This mostly happens when running with -r to enable the race detector and establishing large number of connections simultaneously.

The call to LoadTypes is from this bit of our code:

// registerPostgresTypes registers custom types with pgx that this connection will need
func registerPostgresTypes(ctx context.Context, conn *pgx.Conn) error {
	// try to programatically find all the necessary composite types to register
	rows, _ := conn.Query(ctx, findCompositesSql)
	foundTypes, err := pgx.CollectRows(rows, pgx.RowTo[string])
	if err != nil {
		return fmt.Errorf("unable to find custom composite types: %w", err)
	}

	// This both deduplicates and ensures we add arrays as well
	// If there are no types we are done (LoadTypes errors on an empty list)
	typeNames := finalizeTypes(foundTypes)
	if len(typeNames) == 0 {
		return nil
	}

	if conn.IsClosed() {
		return errors.New("connection closed prior to conn.LoadTypes")
	}

	// use pgx to build the pgtype.Type objects for these required types.
	datatypes, err := conn.LoadTypes(ctx, typeNames)
	if err != nil {
		return fmt.Errorf("unable to load type information from postgres: %w", err)
	}

	if conn.IsClosed() {
		return errors.New("conn.LoadTypes closed the connection")
	}

	// To support the PostScanner interface for composite types we need to wrap the underlying codec
	for _, datatype := range datatypes {
		if base, ok := datatype.Codec.(*pgtype.CompositeCodec); ok {
			datatype.Codec = &CompositeCodecWrapper{CompositeCodec: base}
		}
	}

	conn.TypeMap().RegisterTypes(datatypes)
	return nil
}

And our AfterConnect that invokes the above function

config.AfterConnect = func(ctx context.Context, conn *pgx.Conn) (connErr error) {
		defer func() {
			if connErr != nil {
				log.Printf("AfterConnect returning error: %s", connErr)
			}
		}()

		// turn on tracing of the postgres protocol if requested
		if protoTracer := pgxProtoTracer.Load(); protoTracer != nil {
			conn.PgConn().Frontend().Trace(protoTracer.writer, pgproto3.TracerOptions{})
		}

		// If we've been told to skip registering pastegres types then there is
		// no further setup to do for this connection
		if disablePastegresTypes {
			return nil
		}

		// Perform various bits of work that are needed to have our types work with pgx
		// For uuid we want to allow using pboreman, for timestamps we add utc and infinity changes
		// finally we also need to load information from postgres on any composites we use
		registerUUID(ctx, conn)
		registerTimeTypes(ctx, conn)
		err := registerPostgresExtensionTypes(ctx, conn)
		if err != nil {
			return fmt.Errorf("registering extension types failed: %w", err)
		}

		err = registerPostgresTypes(ctx, conn)
		if err != nil {
			return fmt.Errorf("registering custom types failed: %w", err)
		}

		return nil
	}

The above functions log messages like

2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to find custom composite types: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: While generating load types query: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: While generating load types query: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: While generating load types query: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: While generating load types query: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: While generating load types query: context canceled
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection
2026/05/04 20:45:53 AfterConnect returning error: registering custom types failed: conn.LoadTypes closed the connection

[jaltavilla]

Sorry for the long and meandering issue. I believe I've identified the bug in LoadTypes. It is missing a rows.Err() check after the loop, I replaced the manual loop with ForEachRow. With this change LoadTypes now either succeeds or returns an error. Logs now only contain

2026/05/04 21:34:04 AfterConnect returning error: registering custom types failed: unable to load type information from postgres: context canceled

I don't yet understand why LoadTypes is resulting in a context cancelled. Logs from AFterConnect show the timeout taking ~63ms and the context's deadline over 1m9s away.