Content-Type: multipart/mixed;
 boundary=272ebcbb09b39a377d7185247521ed23de05e64c5bf390e17d5cc619d44c
Mime-Version: 1.0
Date: Thu, 29 Jan 2026 11:02:45 -0300
Message-Id: <DG14NFEZD6M8.QIUMWJP9OCA6@gmail.com>
To: "Masahiko Sawada" <sawada.mshk@gmail.com>, "Matheus Alcantara"
 <matheusssilv97@gmail.com>
Cc: "Andrew Dunstan" <andrew@dunslane.net>, "jian he"
 <jian.universality@gmail.com>, "Tomas Vondra" <tomas@vondra.me>,
 <pgsql-hackers@postgresql.org>
Subject: Re: postgres_fdw: Use COPY to speed up batch inserts
From: "Matheus Alcantara" <matheusssilv97@gmail.com>
References: <DDIZJ217OUDK.2R5WE4OGL5PTY@gmail.com>
 <af99c828-ef24-4355-92d5-b5f631cda9c9@vondra.me>
 <CAFY6G8ePwjT8GiJX1AK5FDMhfq-sOnny6optgTPg98HQw7oJ0g@mail.gmail.com>
 <DDP9DDKVIYQ0.2LTDOCAWGG9M6@gmail.com>
 <CACJufxGgnX91Kzp-kJ03uZp2-sAPtuOpxxjhcigN72Z7BcYRZA@mail.gmail.com>
 <DDQRIXD8K0Z4.YO9AP5L8F4TI@gmail.com>
 <CACJufxFXhAuFDfQS=N0nCaFFTi08__cfwh6E7LhDuuJiAEo=Ww@mail.gmail.com>
 <DDV8CK8EJQQ0.DWQGFW2NOCGU@gmail.com>
 <5c52f4c7-74fa-4594-8378-53fd49f39329@dunslane.net>
 <DDWQNL7GDSXK.2OK2O16JOATAE@gmail.com>
 <DE20J06SWW40.IN0FOXQSFUEA@gmail.com>
 <CAD21AoDFisd4HYcDspqkzoM9sMofba8aBMgB0RkG8uCqt-ZQUg@mail.gmail.com>
 <DEC5ZS2XP2NS.JQ6DH0KUWNL7@gmail.com>
 <CAD21AoBhVS1R8pzvMePsp4ngRTvwOeM0qTkqFmFOj_F9LGNFuw@mail.gmail.com>
 <DEIX9LJ0S9KG.19VG2P7S0I793@gmail.com>
 <DEVDFCCDBMBS.X39YHQNM1HFJ@gmail.com>
 <CAD21AoCMNawy_72g1pc2JU0fp3X1_a_ce-ZQ6P9+YmdMMg-4Rg@mail.gmail.com>
 <DFEE251CWTA8.1LZ18ECCPK79K@gmail.com>
 <CAD21AoAji7ETO0815Cac=7yrntB5o4qiJ9O0LaAH=bDpFAxdyA@mail.gmail.com>
In-Reply-To: 
 <CAD21AoAji7ETO0815Cac=7yrntB5o4qiJ9O0LaAH=bDpFAxdyA@mail.gmail.com>
Archived-At: 
 <https://www.postgresql.org/message-id/DG14NFEZD6M8.QIUMWJP9OCA6%40gmail.com>
Precedence: bulk

--272ebcbb09b39a377d7185247521ed23de05e64c5bf390e17d5cc619d44c
Content-Type: multipart/alternative;
 boundary=1cc6e1bb175212d0b3c0a44794ea4c7124168cd3074c5059461d48fc9d72

--1cc6e1bb175212d0b3c0a44794ea4c7124168cd3074c5059461d48fc9d72
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
Content-Type: text/plain; charset=UTF-8

On Tue Jan 27, 2026 at 4:17 PM -03, Masahiko Sawada wrote:
> On Fri, Jan 2, 2026 at 12:33=E2=80=AFPM Matheus Alcantara
> <matheusssilv97@gmail.com> wrote:
>>
>> On Fri Jan 2, 2026 at 5:15 PM -03, Masahiko Sawada wrote:
>> > +
>> > +   /*
>> > +    * Set batch_with_copy_threshold from foreign server/table options=
. We do
>> > +    * this outside of create_foreign_modify() because we only want to=
 use
>> > +    * COPY as a remote SQL when a COPY FROM on a foreign table is exe=
cuted or
>> > +    * an insert is being performed on a table partition. In both case=
s the
>> > +    * BeginForeignInsert fdw routine is called.
>> > +    */
>> > +   fmstate->batch_with_copy_threshold =3D get_batch_with_copy_thresho=
ld(rel);
>> >
>> > Does it mean that we could end up using the COPY method not only when
>> > executing COPY FROM but also when executing INSERT with tuple
>> > routings? If so, how does the EXPLAIN command show the remote SQL?
>> >
>> It meas that we could also use the COPY method to insert rows into a
>> specific table partition that is a foreign table.
>>
>> Let's say that an user execute an INSERT INTO on a partitioned table
>> that has partitions that are postgres_fdw tables, with this patch we
>> could use the COPY method to insert the rows on these partitions. On
>> this scenario we would not have issue with EXPLAIN output because
>> currently we do not show the remote SQL being executed on each partition
>> that is involved on the INSERT statement.
>>
>> If an user execute an INSERT directly into a postgres_fdw table we will
>> use the normal INSERT statement as we use today.
>
> I'm slightly concerned that it could be confusing for users if we use
> the COPY method for the same table based on not only
> batch_with_copy_threshold but also how to INSERT. For example, if we
> insert tuples directly to a leaf partition, we always use INSERT. On
> the other hand, if we insert tuples via its parent table, we would use
> either COPY or INSERT based on the number of tuples and
> batch_with_copy_threshold value. IIUC this behavior stems from FDW API
> design (BeginForeignInsert callback is called only in cases of COPY or
> tuple routing), which users would not be aware of in general. Also,
> inserting tuples directly to a leaf partition is faster in general
> than doing via the parent table, but the COPY method optimization is
> available only in the latter case.

Yeah, I agree that this patch ends up in a land that it could introduce
more confusing than improvements for the user.

> How about making use of COPY method only when users execute a COPY
> command? Which seems more intuitive and a good start. We can
> distinguish BeginForeignInsert called via COPY from called via INSERT
> (tuple routing) by adding a flag to ModifyTableState or by checking if
> the passed resultRelInfo =3D=3D resultRelInfo->ri_RootResultRelInfo.

This sounds a good idea, it simplify the patch scope a lot. During my
tests I've noticed that ri_RootResultRelInfo is null when it's being
called by CopyFrom(), so on postgresBeginForeignInsert I've included a
check that if it's null it means that it's being executed by a COPY
command and then we could use the COPY command as remote SQL.

Note that using COPY as the remote SQL is not always feasible. If the
remote table has a trigger that modifies the row, and the local foreign
table also has an insert trigger, we cannot capture those changes. While
postgres_fdw typically relies on INSERT ... RETURNING * to synchronize
the TupleTableSlot with remote side effects, the COPY command does not
support a RETURNING clause. Without this synchronization, local triggers
would see the original data rather than the actual values inserted. This
limitation is why the ri_TrigDesc =3D=3D NULL check is necessary; removing
it causes the "Test a combination of local and remote triggers"
regression test on postgres_fdw.sql to fail.

> Alternative idea (or an improvement) would be to use the COPY method
> whenever the number of buffered tuples exceeds the threshold. It would
> cover more cases. Regarding the issue with EXPLAIN output, we could
> output both queries (INSERT and COPY) with some contexts (e.g., the
> threshold for the COPY method etc).

We could implement this as a future improvement.

--
Matheus Alcantara
EDB: https://www.enterprisedb.com


--1cc6e1bb175212d0b3c0a44794ea4c7124168cd3074c5059461d48fc9d72--

--272ebcbb09b39a377d7185247521ed23de05e64c5bf390e17d5cc619d44c
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename=v10-0001-postgres_fdw-Use-COPY-as-remote-SQL-when-possibl.patch
Content-Type: text/plain; charset=utf-8;
 name=v10-0001-postgres_fdw-Use-COPY-as-remote-SQL-when-possibl.patch
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=
--272ebcbb09b39a377d7185247521ed23de05e64c5bf390e17d5cc619d44c--