Content-Type: multipart/mixed;
 boundary=5264fb5fc1befff99bb8434c7c69834b67c6960b9824929fe9b5da615de4
Mime-Version: 1.0
Date: Wed, 22 Oct 2025 21:00:46 -0300
Message-Id: <DDP9DDKVIYQ0.2LTDOCAWGG9M6@gmail.com>
From: "Matheus Alcantara" <matheusssilv97@gmail.com>
To: "Matheus Alcantara" <matheusssilv97@gmail.com>, "Tomas Vondra"
 <tomas@vondra.me>, <pgsql-hackers@postgresql.org>
Subject: Re: postgres_fdw: Use COPY to speed up batch inserts
References: <DDIZJ217OUDK.2R5WE4OGL5PTY@gmail.com>
 <af99c828-ef24-4355-92d5-b5f631cda9c9@vondra.me>
 <CAFY6G8ePwjT8GiJX1AK5FDMhfq-sOnny6optgTPg98HQw7oJ0g@mail.gmail.com>
In-Reply-To: 
 <CAFY6G8ePwjT8GiJX1AK5FDMhfq-sOnny6optgTPg98HQw7oJ0g@mail.gmail.com>
Archived-At: 
 <https://www.postgresql.org/message-id/DDP9DDKVIYQ0.2LTDOCAWGG9M6%40gmail.com>
Precedence: bulk

--5264fb5fc1befff99bb8434c7c69834b67c6960b9824929fe9b5da615de4
Content-Type: multipart/alternative;
 boundary=477c8415b029ea69c9cc11ddceb36d833646408fc6b6c423fd0297d39518

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

On Tue Oct 21, 2025 at 11:25 AM -03, Matheus Alcantara wrote:
>>> Lastly, I don't know if we should change the EXPLAIN(ANALYZE, VERBOSE)
>>> output for batch inserts that use the COPY to mention that we are
>>> sending the COPY command to the remote server. I guess so?
>>>
>>
>> Good point. We definitely should not show SQL for INSERT, when we're
>> actually running a COPY.
>>
> This seems a bit tricky to implement. The COPY is used based on the
> number of slots into the TupleTableSlot array that is used for batch
> insert. The numSlots that execute_foreign_modify() receive is coming
> from ResultRelInfo->ri_NumSlots during ExecInsert(). We don't have this
> information during EXPLAIN that is handled by
> postgresExplainForeignModify(), we only have the
> ResultRelInfo->ri_BatchSize at this stage. The current idea is to use
> the COPY command if the number of slots is > 1 so I'm wondering if we
> should use another mechanism to enable the COPY usage, for example, we
> could just use if the batch_size is configured to a number greater than
> X, but what if the INSERT statement is only inserting a single row,
> should we still use the COPY command to ingest a single row into the
> foreign table? Any thoughts?
>
Thinking more about this I realize that when we are deparsing the remote
SQL to be sent to the foreign server at the planner phase (via
postgresPlanForeignModify()) we don't have the batch_size and number of
rows information, so currently we can not know at the plan time if the
COPY usage for a batch insert is visible or not because IIUC these
information are only visible at query runtime.

One way to make it possible is that we could simply use the
PgFdwModifyState->copy_data during postgresExplainForeignModify() if
it's not null. Since we will only have this information during query
execution the drawback of this approach is that we would only show the
COPY as a Remote SQL on during EXPLAIN(ANALYZE).

Please see the attached v3 version that implements this idea.

> I tried to reuse the fmstate->query field to cache the COPY sql but
> running the postgres_fdw.sql regress test shows that this may not
> work. When we are running a user supplied COPY command on a foreign
> table the CopyMultiInsertBufferFlush() call
> ri_FdwRoutine->ExecForeignBatchInsert which may pass different values
> for numSlots based on the number of slots already sent to the foreign
> server, and eventually it may pass numSlots as 1 which will not use the
> COPY under the hood to send to the foreign server and if we cache the
> COPY command into the fmstate->query this will not work because the
> normal INSERT path on execute_foreign_modify uses the fmstate->query to
> build a prepared statement to send to the foreign server. So basically
> what I'm trying to say is that when the server is executing a COPY into
> a foreign it may use the COPY command or INSERT command to send the data
> to the foreign server. That being said, I decided to create a new
> copy_query field on PgFdwModifyState to cache only COPY commands. Please
> let me know if my understanding is wrong or if we could have a better
> approach here.
>
Based on the information that I've mention above I think that we need
some way to not mix INSERT with COPY commands when executing a COPY in
a foreign table supplied by the user. Or we should disable the COPY
under the hood and always fallback to INSERT or enable the COPY to use
when the *numSlots is 1, so in case of an EXPLAIN(ANALYZE) output we can
show the Remote SQL correctly. Is that make sense?

I'm still not sure if the trigger to use the COPY command for batch
insert should be *numSlots > 1 or something else. I'm open for better
ideas.

Thoughts?

--
Matheus Alcantara


--477c8415b029ea69c9cc11ddceb36d833646408fc6b6c423fd0297d39518--

--5264fb5fc1befff99bb8434c7c69834b67c6960b9824929fe9b5da615de4
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename=v3-0001-postgres_fdw-Use-COPY-to-speed-up-batch-inserts.patch
Content-Type: text/plain; charset=utf-8;
 name=v3-0001-postgres_fdw-Use-COPY-to-speed-up-batch-inserts.patch
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--5264fb5fc1befff99bb8434c7c69834b67c6960b9824929fe9b5da615de4--