MIME-Version: 1.0
From: Rafia Sabih <rafia.pghackers@gmail.com>
Date: Mon, 6 Jan 2025 09:52:10 +0100
Message-ID: <CA+FpmFcmO5ctjYgQxSomJC=mCugqPo+51Le2wdxX0kWxjvBBig@mail.gmail.com>
Subject: Bypassing cursors in postgres_fdw to enable parallel plans
To: PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Cc: Robert Haas <robertmhaas@gmail.com>
Content-Type: multipart/mixed; boundary="000000000000340653062b05bfe3"
Archived-At: <https://www.postgresql.org/message-id/CA%2BFpmFcmO5ctjYgQxSomJC%3DmCugqPo%2B51Le2wdxX0kWxjvBBig%40mail.gmail.com>
Precedence: bulk

--000000000000340653062b05bfe3
Content-Type: multipart/alternative; boundary="000000000000340652062b05bfe1"

--000000000000340652062b05bfe1
Content-Type: text/plain; charset="UTF-8"

Hello hackers,

At present, in postgres_fdw, if a query which is using a parallel plan is
fired from the remote end fails to use the parallel plan locally because of
the presence of CURSORS. Consider the following example,
Local server,
Table:
create table t ( i int, j int, k text);
insert into t values(generate_series(1,10000), generate_series(1, 10000),
'check_this_out');
Query
select * from t where i > 1000;
Query plan
Gather  (cost=0.00..116.08 rows=9000 width=23)
 Workers Planned: 2
 ->  Parallel Seq Scan on t  (cost=0.00..116.08 rows=3750 width=23)
       Filter: (i > 1000)

Foreign server
create extension postgres_fdw;
CREATE SERVER foreign_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS
(host '127.0.0.1', port '5432', dbname 'postgres');
CREATE USER MAPPING FOR user1 SERVER foreign_server OPTIONS (user 'user1');
Table
CREATE FOREIGN TABLE foreign_table ( i int, j int, k text ) SERVER
foreign_server OPTIONS (schema_name 'public', table_name 't');
Query
select * from t where i > 1000;
Query plan at the local server
Seq Scan on t  (cost=0.00..189.00 rows=9000 width=23)
Filter: (i > 1000)

I have used auto_explain extension to get the query plans at the local
server and also following settings in .conf to force the parallel plans for
the purpose of demonstration --
min_parallel_table_scan_size = 0
parallel_tuple_cost= 0
parallel_setup_cost = 0

with the patch:
set postgres_fdw.use_cursor = false;
Query plan at the local server
 Gather  (cost=0.00..116.08 rows=9000 width=23)
 Workers Planned: 2
 ->  Parallel Seq Scan on t  (cost=0.00..116.08 rows=3750 width=23)
       Filter: (i > 1000)

Now, to overcome this limitation, I have worked on this idea (suggested by
my colleague Bernd Helmle) of bypassing the cursors. The way it works is as
follows,
there is a new GUC introduced postgres_fdw.use_cursor, which when unset
uses the mode without the cursor. Now, it uses PQsetChunkedRowsMode in
create_cursor when non-cursor mode is used. The size of the chunk is the
same as the fetch_size. Now in fetch_more_data, when non-cursor mode is
used, pgfdw_get_next_result is used to get the chunk in PGresult and
processed in the same manner as before.

Now, the issue comes when there are simultaneous queries, which is the case
with the join queries where all the tables involved in the join are at the
local server. Because in that case we have multiple cursors opened at the
same time and without a cursor mechanism we do not have any information or
any other structure to know what to fetch from which query. To handle that
case, we have a flag only_query, which is unset as soon as we have assigned
the cursor_number >= 2, in postgresBeginForeignScan. Now, in fetch_more
data, when we find out that only_query is unset, then we fetch all the data
for the query and store it in a Tuplestore. These tuples are then
transferred to the fsstate->tuples and then processed as usual.

So yes there is a performance drawback in the case of simultaneous queries,
however, the ability to use parallel plans is really an added advantage for
the users. Plus, we can keep things as before by this new GUC --
use_cursor, in case we are losing more for some workloads.  So, in short I
feel hopeful that this could be a good idea and a good time to improve
postgres_fdw.

Looking forward to your reviews, comments, etc.
-- 
Regards,
Rafia Sabih
CYBERTEC PostgreSQL International GmbH

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

<div dir=3D"ltr"><div>Hello hackers,</div><div><br></div><div>At present, i=
n postgres_fdw, if a query which is using a parallel plan is fired from the=
 remote end fails to use the parallel plan locally=C2=A0because=C2=A0of the=
 presence of CURSORS. Consider the following example,</div><div>Local serve=
r,</div><div>Table:=C2=A0=C2=A0</div><div>create table t ( i int, j int, k =
text);</div>insert into t values(generate_series(1,10000), generate_series(=
1, 10000), &#39;check_this_out&#39;);<br><div>Query</div><div>select * from=
 t where i &gt; 1000;</div><div>Query plan</div><div>Gather =C2=A0(cost=3D0=
.00..116.08 rows=3D9000 width=3D23)<br>	 =C2=A0Workers Planned: 2<br>	 =C2=
=A0-&gt; =C2=A0Parallel Seq Scan on t =C2=A0(cost=3D0.00..116.08 rows=3D375=
0 width=3D23)<br>	 =C2=A0 =C2=A0 =C2=A0 =C2=A0Filter: (i &gt; 1000)</div><d=
iv><br></div><div>Foreign server</div><div>create extension postgres_fdw;<b=
r>CREATE SERVER foreign_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS (h=
ost &#39;127.0.0.1&#39;, port &#39;5432&#39;, dbname &#39;postgres&#39;);<b=
r></div><div>CREATE USER MAPPING FOR user1 SERVER foreign_server OPTIONS (u=
ser &#39;user1&#39;);</div><div>Table</div><div>CREATE FOREIGN TABLE foreig=
n_table ( i int, j int, k text ) SERVER foreign_server OPTIONS (schema_name=
 &#39;public&#39;, table_name &#39;t&#39;);<br></div><div>Query</div><div>s=
elect * from t where i &gt; 1000;</div><div>Query plan at the local server<=
/div><div>Seq Scan on t =C2=A0(cost=3D0.00..189.00 rows=3D9000 width=3D23)<=
br>Filter: (i &gt; 1000)</div><div><br></div><div>I have used auto_explain =
extension to get the query plans at the local server and also following=C2=
=A0settings in .conf to force the parallel plans for the purpose of demonst=
ration --=C2=A0</div><div>min_parallel_table_scan_size =3D 0=C2=A0 =C2=A0 =
=C2=A0 =C2=A0=C2=A0</div>parallel_tuple_cost=3D 0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0<br>parallel_setup_cost =3D 0=C2=A0=
=C2=A0<div><br></div><div>with the patch:</div><div>set postgres_fdw.use_cu=
rsor =3D false;</div><div>Query plan at the local server</div><div>=C2=A0Ga=
ther =C2=A0(cost=3D0.00..116.08 rows=3D9000 width=3D23)</div>	 =C2=A0Worker=
s Planned: 2<br>	 =C2=A0-&gt; =C2=A0Parallel Seq Scan on t =C2=A0(cost=3D0.=
00..116.08 rows=3D3750 width=3D23)<br>	 =C2=A0 =C2=A0 =C2=A0 =C2=A0Filter: =
(i &gt; 1000)<br><div><br></div><div>Now, to overcome this limitation, I ha=
ve worked on this idea (suggested by my colleague Bernd Helmle) of bypassin=
g the cursors. The way it works is as follows,</div><div><div>there is a ne=
w GUC introduced postgres_fdw.use_cursor, which when unset uses the mode wi=
thout the cursor. Now, it uses=C2=A0PQsetChunkedRowsMode in create_cursor w=
hen non-cursor mode is used. The size of the chunk is the same=C2=A0as the =
fetch_size. Now in fetch_more_data, when non-cursor mode is used,=C2=A0pgfd=
w_get_next_result is used to get the chunk in PGresult and processed in the=
 same manner as before.</div></div><div><br></div><div>Now, the issue comes=
 when there are simultaneous=C2=A0queries, which is the case with the join =
queries where all the tables involved in the join are at the local server. =
Because in that case we have multiple cursors opened at the same time and w=
ithout a cursor mechanism we do not have any information or any other struc=
ture to know what to fetch from which query. To handle that case, we have a=
 flag only_query, which is unset as soon as we have assigned the cursor_num=
ber &gt;=3D 2, in postgresBeginForeignScan. Now, in fetch_more data, when w=
e find out that only_query is unset, then we fetch all the data for the que=
ry and store it in a Tuplestore. These tuples are then transferred to the f=
sstate-&gt;tuples and then processed as usual.</div><div><br></div><div>So =
yes there=C2=A0is=C2=A0a=C2=A0performance drawback in the=C2=A0case of simu=
ltaneous queries, however, the=C2=A0ability to use parallel plans is really=
 an added advantage for the=C2=A0users. Plus, we can keep things=C2=A0as=C2=
=A0before by this=C2=A0new=C2=A0GUC -- use_cursor, in case we are losing mo=
re for some=C2=A0workloads.=C2=A0 So, in short I feel hopeful that this cou=
ld be a good idea and a good time to improve postgres_fdw.</div><div><br></=
div><div>Looking forward to your reviews, comments, etc.</div><span class=
=3D"gmail_signature_prefix">-- </span><br><div dir=3D"ltr" class=3D"gmail_s=
ignature" data-smartmail=3D"gmail_signature"><div dir=3D"ltr">Regards,<br>R=
afia Sabih<div>CYBERTEC PostgreSQL International GmbH<br></div></div></div>=
</div>

--000000000000340652062b05bfe1--
--000000000000340653062b05bfe3
Content-Type: application/octet-stream; 
	name="0001-Add-a-fetch-mechanism-without-cursors.patch"
Content-Disposition: attachment; 
	filename="0001-Add-a-fetch-mechanism-without-cursors.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_m5ksfaee0>
X-Attachment-Id: f_m5ksfaee0
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--000000000000340653062b05bfe3--