Content-Type: multipart/mixed; boundary="------------YfcVNB0Q6knCAIBMMSe97GUm"
Message-ID: <151e835f-55d6-ddbc-b5b4-07ee606aba44@enterprisedb.com>
Date: Fri, 11 Feb 2022 18:02:37 +0100
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101
 Thunderbird/91.5.0
Content-Language: en-US
To: PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
From: Tomas Vondra <tomas.vondra@enterprisedb.com>
Subject: postgres_fdw: using TABLESAMPLE to collect remote sample
Archived-At: 
 <https://www.postgresql.org/message-id/151e835f-55d6-ddbc-b5b4-07ee606aba44%40enterprisedb.com>
Precedence: bulk

This is a multi-part message in MIME format.
--------------YfcVNB0Q6knCAIBMMSe97GUm
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Hi,

here's a small patch modifying postgres_fdw to use TABLESAMPLE to 
collect sample when running ANALYZE on a foreign table. Currently the 
sampling happens locally, i.e. we fetch all data from the remote server 
and then pick rows. But that's hugely expensive for large relations 
and/or with limited network bandwidth, of course.

Alexander Lepikhov mentioned this in [1], but it was actually proposed 
by Stephen in 2020 [2] but no patch even materialized.

So here we go. The patch does a very simple thing - it uses TABLESAMPLE 
to collect/transfer just a small sample from the remote node, saving 
both CPU and network.

And indeed, that helps quite a bit:

---------------------------------------------------------------------
create table t (a int);
Time: 10.223 ms

insert into t select i from generate_series(1,10000000) s(i);
Time: 552.207 ms

analyze t;
Time: 310.445 ms

CREATE FOREIGN TABLE ft (a int)
   SERVER foreign_server
   OPTIONS (schema_name 'public', table_name 't');
Time: 4.838 ms

analyze ft;
WARNING:  SQL: DECLARE c1 CURSOR FOR SELECT a FROM public.t TABLESAMPLE 
SYSTEM(0.375001)
Time: 44.632 ms

alter foreign table ft options (sample 'false');
Time: 4.821 ms

analyze ft;
WARNING:  SQL: DECLARE c1 CURSOR FOR SELECT a FROM public.t
Time: 6690.425 ms (00:06.690)
---------------------------------------------------------------------

6690ms without sampling, and 44ms with sampling - quite an improvement. 
Of course, the difference may be much smaller/larger in other cases.

Now, there's a couple issues ...

Firstly, the FDW API forces a bit strange division of work between 
different methods and duplicating some of it (and it's already mentioned 
in postgresAnalyzeForeignTable). But that's minor and can be fixed.

The other issue is which sampling method to use - we have SYSTEM and 
BERNOULLI built in, and the tsm_system_rows as an extension (and _time, 
but that's not very useful here). I guess we'd use one of the built-in 
ones, because that'll work on more systems out of the box.

But that leads to the main issue - determining the fraction of rows to 
sample. We know how many rows we want to sample, but we have no idea how 
many rows there are in total. We can look at reltuples, but we can't be 
sure how accurate / up-to-date that value is.

The patch just trusts it unless it's obviously bogus (-1, 0, etc.) and 
applies some simple sanity checks, but I wonder if we need to do more 
(e.g. look at relation size and adjust reltuples by current/relpages).

FWIW this is yet a bit more convoluted when analyzing partitioned table 
with foreign partitions, because we only ever look at relation sizes to 
determine how many rows to sample from each partition.


regards

[1] 
https://www.postgresql.org/message-id/bdb0bea2-a0da-1f1d-5c92-96ff90c198eb%40postgrespro.ru

[2] 
https://www.postgresql.org/message-id/20200829162231.GE29590%40tamriel.snowman.net

-- 
Tomas Vondra
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--------------YfcVNB0Q6knCAIBMMSe97GUm
Content-Type: text/x-patch; charset=UTF-8;
 name="postgres-fdw-analyze-sample-20220211.patch"
Content-Disposition: attachment;
 filename="postgres-fdw-analyze-sample-20220211.patch"
Content-Transfer-Encoding: base64
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--------------YfcVNB0Q6knCAIBMMSe97GUm--