MIME-Version: 1.0
From: Alexander Korotkov <aekorotkov@gmail.com>
Date: Sat, 4 Jul 2026 01:00:16 +0300
Message-ID: 
 <CAPpHfduMOTnV5Zj2KGJ7zanL_10QvccZHtPUaDfJvBhsh9axnQ@mail.gmail.com>
Subject: Bug in asynchronous Append
To: pgsql-hackers <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000813d5b0655bc0de7"
Archived-At: 
 <https://www.postgresql.org/message-id/CAPpHfduMOTnV5Zj2KGJ7zanL_10QvccZHtPUaDfJvBhsh9axnQ%40mail.gmail.com>
Precedence: bulk

--000000000000813d5b0655bc0de7
Content-Type: multipart/alternative; boundary="000000000000813d5b0655bc0de5"

--000000000000813d5b0655bc0de5
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi!

ExecReScanAppend() unconditionally resets callback_pending for all
AsyncRequests.  The problem is that postgres_fdw keeps its own knowledge
for the same fact: PgFdwConnState.pendingAreq =E2=80=93 a pointer to "pendi=
ng async
request" for a given connection.  That connection can be shared by several
partitions/foreign tables (postgres_fdw caches one connection per
server+usermapping pair). The blind reset in nodeAppend.c only touches the
local AsyncRequest.callback_pending; it never touches
PgFdwConnState.pendingAreq, which correctly points to the still-dangling
request.

Later, when another partition sharing that same connection gets its own
ReScan (for instance, its chgParam changed because of the LATERAL
parameter, and it already has a cursor open), it sends "CLOSE cursor" via
pgfdw_exec_query().  Before sending any new command on the connection, that
function first drains whatever request is still outstanding on it:

if (state && state->pendingAreq)
    process_pending_request(state->pendingAreq);

And process_pending_request() starts with:

Assert(areq->callback_pending);

=E2=80=93 which fails, because the flag was corrupted some rounds earlier.

The attached patch contains both the reproduction case and the fix.  The
fix postpones the reset of the callback_pending flag
to ExecAppendAsyncBegin().  ExecAppendAsyncBegin() performs this cleanup
along with ExecReScan(), which completes the async fetch.

------
Regards,
Alexander Korotkov
Supabase

--000000000000813d5b0655bc0de5
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">Hi!<br><br>ExecReScanAppend() unconditionally resets callb=
ack_pending for all AsyncRequests.=C2=A0 The problem is that postgres_fdw k=
eeps its own knowledge for the same fact: PgFdwConnState.pendingAreq =E2=80=
=93 a pointer to &quot;pending async request&quot; for a given connection.=
=C2=A0 That connection can be shared by several partitions/foreign tables (=
postgres_fdw caches one connection per server+usermapping pair). The blind =
reset in nodeAppend.c only touches the local AsyncRequest.callback_pending;=
 it never touches PgFdwConnState.pendingAreq, which correctly points to the=
 still-dangling request.<br><br>Later, when another partition sharing that =
same connection gets its own ReScan (for instance, its chgParam changed bec=
ause of the LATERAL parameter, and it already has a cursor open), it sends =
&quot;CLOSE cursor&quot; via pgfdw_exec_query().=C2=A0 Before sending any n=
ew command on the connection, that function first drains whatever request i=
s still outstanding on it:<br><br><font face=3D"monospace">if (state &amp;&=
amp; state-&gt;pendingAreq)<br>=C2=A0 =C2=A0 process_pending_request(state-=
&gt;pendingAreq);<br></font><br>And process_pending_request() starts with:<=
br><br><div><font face=3D"monospace">Assert(areq-&gt;callback_pending);<br>=
</font><br><div>=E2=80=93 which fails, because the flag was corrupted some =
rounds earlier.<br><br></div><div>The attached patch contains both the repr=
oduction case and the fix.=C2=A0 The fix postpones=C2=A0the reset of the ca=
llback_pending flag to=C2=A0ExecAppendAsyncBegin().=C2=A0=C2=A0<span style=
=3D"background-color:transparent">ExecAppendAsyncBegin()=C2=A0</span><span =
style=3D"background-color:transparent">performs this cleanup along with </s=
pan><span style=3D"background-color:transparent">ExecReScan(), which comple=
tes the</span><span style=3D"background-color:transparent">=C2=A0async fetc=
h</span><span style=3D"background-color:transparent">.</span></div><div><br=
></div><div>------<br>Regards,<br>Alexander Korotkov<br>Supabase</div></div=
></div>

--000000000000813d5b0655bc0de5--

--000000000000813d5b0655bc0de7
Content-Type: application/octet-stream;
	name="v1-0001-Fix-corruption-of-async-request-state-on-Append-r.patch"
Content-Disposition: attachment;
	filename="v1-0001-Fix-corruption-of-async-request-state-on-Append-r.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mr5h31950>
X-Attachment-Id: f_mr5h31950
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--000000000000813d5b0655bc0de7--