From: Ronan Dunklau <ronan.dunklau@aiven.io>
To: PostgreSQL Developers <pgsql-hackers@lists.postgresql.org>
Cc: David Rowley <dgrowleyml@gmail.com>
Subject: Re: Allow ordered partition scans in more cases
Date: Wed, 22 Feb 2023 14:10:48 +0100
Message-ID: <2868814.e9J7NaK4W3@aivenlaptop>
In-Reply-To:
 <CAApHDvojKdBR3MR59JXmaCYbyHB6Q_5qPRU+dy93En8wm+XiDA@mail.gmail.com>
References:
 <CAApHDvojKdBR3MR59JXmaCYbyHB6Q_5qPRU+dy93En8wm+XiDA@mail.gmail.com>
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset="iso-8859-1"
Archived-At: <https://www.postgresql.org/message-id/2868814.e9J7NaK4W3%40aivenlaptop>
Precedence: bulk

Thank you for improving this optimization !

Le mardi 21 f=E9vrier 2023, 04:14:02 CET David Rowley a =E9crit :
> I still need to look to see if there's some small amount of data that
> can be loaded into the table to help coax the planner into producing
> the ordered scan for this one.  It works fine as-is for ORDER BY a,b
> and ORDER BY a; so I've put tests in for that.

I haven't looked too deeply into it, but it seems reasonable that the whole=
=20
sort would cost cheaper than individual sorts on partitions + incremental=20
sorts, except when the the whole sort would spill to disk much more than th=
e=20
incremental ones. I find it quite difficult to reason about what that thres=
hold=20
should be, but I managed to find a case which could fit in a test:

create table range_parted (a int, b int, c int) partition by range(a, b);
create table range_parted1 partition of range_parted for values from (0,0) =
to=20
(10,10);
create table range_parted2 partition of range_parted for values from (10,10=
)=20
to (20,20);
insert into range_parted(a, b, c) select i, j, k from generate_series(1, 19=
)=20
i, generate_series(1, 19) j, generate_series(1, 5) k;
analyze range_parted;
set random_page_cost =3D 10;
set work_mem =3D '64kB';
explain (costs off) select * from range_parted order by a,b,c;

It's quite convoluted, because it needs the following:
 - estimate the individual partition sorts to fit into work_mem (even if th=
at's=20
not the case here at runtime)
 - estimate the whole table sort to not fit into work_mem
 - the difference between the two should be big enough to compensate the=20
incremental sort penalty (hence raising random_page_cost).

This is completely tangential to the subject at hand, but maybe we have=20
improvements to do with the way we estimate what type of sort will be=20
performed ? It seems to underestimate the memory amount needed. I'm not sur=
e=20
it makes a real difference in real use cases though.=20

Regards,

=2D-
Ronan Dunklau