Unhandled errors thrown during execution of a prepared statement

[jeroenrinzema]

👋🏻 , I am currently working on a PSQL server wire protocol implementation allowing you to create a PSQL server in a few lines of code. I noticed while testing the extended query protocol that errors thrown while executing a prepared statement are not handled. I have opened a PR inside the psql-wire protocol repository which is able to reproduce the issue.

It seems that the error is not handled due to the error not being handled when reading until a row descriptor while executing a prepared query.

pgx/pgconn/pgconn.go

Lines 1480 to 1484 in 74f9b9f

	// Consume the message
	msg, _ = rr.receiveMessage()
	if _, ok := msg.(*pgproto3.RowDescription); ok {
	return
	}

I would like to propose to handle the error returned when reading the next message and to return it to the client.

[jackc]

I don't understand what's going on here. The call to rr.receiveMessage should handle the ErrorResponse.

pgx/pgconn/pgconn.go

Lines 1516 to 1525 in fcec008

	switch msg := msg.(type) {
	case *pgproto3.RowDescription:
	rr.fieldDescriptions = rr.pgConn.convertRowDescription(rr.pgConn.fieldDescriptions[:], msg)
	case *pgproto3.CommandComplete:
	rr.concludeCommand(rr.pgConn.makeCommandTag(msg.CommandTag), nil)
	case *pgproto3.EmptyQueryResponse:
	rr.concludeCommand(CommandTag{}, nil)
	case *pgproto3.ErrorResponse:
	rr.concludeCommand(CommandTag{}, ErrorResponseToPgError(msg))
	}

That will terminate the loop in readUntilRowDescription.

AFAICT pgx is doing the right thing. Can you compare the message traffic with psql-wire to PostgreSQL? (pgproto3.Frontend.Trace might be handy here)

[jeroenrinzema]

Thanks for looking into this! I have been diving a bit deeper into the message flow. The UNIT test I have written returned a FATAL error message causing an error to be returned while receiving a message from the pg conn. The interesting thing is that errors returned during evaluation are not handled within the returned rows. The error is set correctly within the result reader but is not handled inside the baseRows type. I have tested this with errors of different severity levels.

I have compared the message flow of psql-wire to PostgreSQL but was unable to reproduce the throwing of an error during the execution of a prepared statement. Please let me know if you have suggestions on how I could replicate this error message flow inside PostgreSQL.

[jackc]

I just looked a little closer at your test. The problem is the query results are not being read.

This test works:

	t.Run("jackc/pgx", func(t *testing.T) {
		ctx := context.Background()
		connstr := fmt.Sprintf("postgres://%s:%d", address.IP, address.Port)
		conn, err := pgx.Connect(ctx, connstr)
		assert.NoError(t, err)

		rows, _ := conn.Query(ctx, "SELECT *;")
		rows.Close()
		assert.Error(t, rows.Err())

		err = conn.Close(ctx)
		assert.NoError(t, err)
	})

[jeroenrinzema]

Perfect! Thanks for looking into my tests. I have updated the test and everything seems to be working perfectly! We could convert this discussion to an issue and close it if you like.