MIME-Version: 1.0
From: Peter Geoghegan <pg@bowt.ie>
Date: Mon, 24 Jul 2023 18:33:52 -0700
Message-ID: <CAH2-Wz=ksvN_sjcnD1+Bt-WtifRA5ok48aDYnq3pkKhxgMQpcw@mail.gmail.com>
Subject: Optimizing nbtree ScalarArrayOp execution, allowing multi-column
 ordered scans, skip scan
To: PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Cc: Tom Lane <tgl@sss.pgh.pa.us>, Tomas Vondra <tomas.vondra@enterprisedb.com>, 
	Jeff Davis <pgsql@j-davis.com>, benoit <benoit@hopsandfork.com>
Content-Type: multipart/mixed; boundary="000000000000ceb32b060145ba56"
Archived-At: <https://www.postgresql.org/message-id/CAH2-Wz%3DksvN_sjcnD1%2BBt-WtifRA5ok48aDYnq3pkKhxgMQpcw%40mail.gmail.com>
Precedence: bulk

--000000000000ceb32b060145ba56
Content-Type: text/plain; charset="UTF-8"

I've been working on a variety of improvements to nbtree's native
ScalarArrayOpExpr execution. This builds on Tom's work in commit
9e8da0f7.

Attached patch is still at the prototype stage. I'm posting it as v1 a
little earlier than I usually would because there has been much back
and forth about it on a couple of other threads involving Tomas Vondra
and Jeff Davis -- seems like it would be easier to discuss with
working code available.

The patch adds two closely related enhancements to ScalarArrayOp
execution by nbtree:

1. Execution of quals with ScalarArrayOpExpr clauses during nbtree
index scans (for equality-strategy SK_SEARCHARRAY scan keys) can now
"advance the scan's array keys locally", which sometimes avoids
significant amounts of unneeded pinning/locking of the same set of
index pages.

SAOP index scans become capable of eliding primitive index scans for
the next set of array keys in line in cases where it isn't truly
necessary to descend the B-Tree again. Index scans are now capable of
"sticking with the existing leaf page for now" when it is determined
that the end of the current set of array keys is physically close to
the start of the next set of array keys (the next set in line to be
materialized by the _bt_advance_array_keys state machine). This is
often possible.

Naturally, we still prefer to advance the array keys in the
traditional way ("globally") much of the time. That means we'll
perform another _bt_first/_bt_search descent of the index, starting a
new primitive index scan. Whether we try to skip pages on the leaf
level or stick with the current primitive index scan (by advancing
array keys locally) is likely to vary a great deal. Even during the
same index scan. Everything is decided dynamically, which is the only
approach that really makes sense.

This optimization can significantly lower the number of buffers pinned
and locked in cases with significant locality, and/or with many array
keys with no matches. The savings (when measured in buffers
pined/locked) can be as high as 10x, 100x, or even more. Benchmarking
has shown that transaction throughput for variants of "pgbench -S"
designed to stress the implementation (hundreds of array constants)
under concurrent load can have up to 5.5x higher transaction
throughput with the patch. Less extreme cases (10 array constants,
spaced apart) see about a 20% improvement in throughput. There are
similar improvements to latency for the patch, in each case.

2. The optimizer now produces index paths with multiple SAOP clauses
(or other clauses we can safely treat as "equality constraints'') on
each of the leading columns from a composite index -- all while
preserving index ordering/useful pathkeys in most cases.

The nbtree work from item 1 is useful even with the simplest IN() list
query involving a scan of a single column index. Obviously, it's very
inefficient for the nbtree code to use 100 primitive index scans when
1 is sufficient. But that's not really why I'm pursuing this project.
My real goal is to implement (or to enable the implementation of) a
whole family of useful techniques for multi-column indexes. I call
these "MDAM techniques", after the 1995 paper "Efficient Search of
Multidimensional B-Trees" [1][2]-- MDAM is short for "multidimensional
access method". In the context of the paper, "dimension" refers to
dimensions in a decision support system.

The most compelling cases for the patch all involve multiple index
columns with multiple SAOP clauses (especially where each column
represents a separate "dimension", in the DSS sense). It's important
that index sort be preserved whenever possible, too. Sometimes this is
directly useful (e.g., because the query has an ORDER BY), but it's
always indirectly needed, on the nbtree side (when the optimizations
are applicable at all). The new nbtree code now has special
requirements surrounding SAOP search type scan keys with composite
indexes. These requirements make changes in the optimizer all but
essential.

Index order
===========

As I said, there are cases where preserving index order is immediately
and obviously useful, in and of itself. Let's start there.

Here's a test case that you can run against the regression test database:

pg@regression:5432 =# create index order_by_saop on tenk1(two,four,twenty);
CREATE INDEX

pg@regression:5432 =# EXPLAIN (ANALYZE, BUFFERS)
select ctid, thousand from tenk1
where two in (0,1) and four in (1,2) and twenty in (1,2)
order by two, four, twenty limit 20;

With the patch, this query gets 13 buffer hits. On the master branch,
it gets 1377 buffer hits -- which exceeds the number you'll get from a
sequential scan by about 4x. No coaxing was required to get the
planner to produce this plan on the master branch. Almost all of the
savings shown here are related to heap page buffer hits -- the nbtree
changes don't directly help in this particular example (strictly
speaking, you only need the optimizer changes to get this result).

Obviously, the immediate reason why the patch wins by so much is
because it produces a plan that allows the LIMIT to terminate the scan
far sooner. Benoit Tigeot (CC'd) happened to run into this issue
organically -- that was also due to heap hits, a LIMIT, and so on. As
luck would have it, I stumbled upon his problem report (in the
Postgres slack channel) while I was working on this patch. He produced
a fairly complete test case, which was helpful [3]. This example is
more or less just a distillation of his test case, designed to be easy
for a Postgres hacker to try out for themselves.

There are also variants of this query where a LIMIT isn't the crucial
factor, and where index page hits are the problem. This query uses an
index-only scan, both on master and with the patch (same index as
before):

select count(*), two, four, twenty
from tenk1
where two in (0, 1) and four in (1, 2, 3, 4) and
twenty in (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,14,15)
group by two, four, twenty
order by two, four, twenty;

The patch gets 18 buffer hits for this query. That outcome makes
intuitive sense, since this query is highly unselective -- it's
approaching the selectivity of the query "select count(*) from tenk1".
The simple count(*) query gets 19 buffer hits for its own index-only
scan, confirming that the patch managed to skip only one or two leaf
pages in the complicated "group by" variant of the count(*) query.
Overall, the GroupAggregate plan used by the patch is slower than the
simple count(*) case (despite touching fewer pages). But both plans
have *approximately* the same execution cost, which makes sense, since
they both have very similar selectivities.

The master branch gets 245 buffer hits for the same group by query.
This is almost as many hits as a sequential scan would require -- even
though there are precisely zero heap accesses needed by the underlying
index-only scan. As with the first example, no planner coaxing was
required to get this outcome on master. It is inherently very
difficult to predict how selective a query like this will be using
conventional statistics. But that's not actually the problem in this
example -- the planner gets that part right, on this occasion. The
real problem is that there is a multiplicative factor to worry about
on master, when executing multiple SAOPs. That makes it almost
impossible to predict the number of pages we'll pin. While with the
patch, scans with multiple SAOPs are often fairly similar to scans
that happen to just have one on the leading column.

With the patch, it is simply impossible for an SAOP index scan to
visit any single leaf page more than once. Just like a conventional
index scan. Whereas right now, on master, using more than one SAOP
clause for a multi column index seems to me to be a wildly risky
proposition. You can easily have cases that work just fine on master,
while only slight variations of the same query see costs explode
(especially likely with a LIMIT). ISTM that there is significant value
in knowing for sure in having a pretty accurate idea of the worst case
in the planner.

Giving nbtree the ability to skip or not skip dynamically, based on
actual conditions in the index (not on statistics), seems like it has
a lot of potential as a way of improving performance *stability*.
Personally I'm most interested in this aspect of the project.

Note: we can visit internal pages more than once, but that seems to
make a negligible difference to the overall cost profile of scans. Our
policy is to not charge an I/O cost for those pages. Plus, the number
of internal page access is dramatically reduced (it's just not
guaranteed that there won't be any repeat accesses for internal pages,
is all).

Note also: there are hard-to-pin-down interactions between the
immediate problem on the nbtree side, and the use of filter quals
rather than true index quals, where the use of index quals is possible
in principle. Some problematic cases see excessive amounts of heap
page hits only (as with my first example query). Other problematic
cases see excessive amounts of index page hits, with little to no
impact on heap page hits at all (as with my second example query).
Some combination of the two is also possible.

Safety
======

As mentioned already, the ability to "advance the current set of array
keys locally" during a scan (the nbtree work in item 1) actually
relies the optimizer work in item 2 -- it's not just a question of
unlocking the potential of the nbtree work. Now I'll discuss those
aspects in a bit more detail.

Without the optimizer work, nbtree will produce wrong answers to
queries, in a way that resembles the complaint addressed by historical
bugfix commit 807a40c5. This incorrect behavior (if the optimizer were
to permit it) would only be seen when there are multiple
arrays/columns, and an inequality on a leading column -- just like
with that historical bug.  (It works both ways, though -- the nbtree
changes also make the optimizer changes safe by limiting the worst
case, which would otherwise be too much of a risk to countenance. You
can't separate one from the other.)

The primary change on the optimizer side is the addition of logic to
differentiate between the following two cases when building an index
path in indxpath.c:

* Unsafe: Cases where it's fundamentally unsafe to treat
multi-column-with-SAOP-clause index paths as returning tuples in a
useful sort order.

For example, the test case committed as part of that bugfix involves
an inequality, so it continues to be treated as unsafe.

* Safe: Cases where (at least in theory) bugfix commit 807a40c5 went
further than it really had to.

Those cases get to use the optimization, and usually get to have
useful path keys.

My optimizer changes are very kludgey. I came up with various ad-hoc
rules to distinguish between the safe and unsafe cases, without ever
really placing those changes into some kind of larger framework. That
was enough to validate the general approach in nbtree, but it
certainly has problems -- glaring problems. The biggest problem of all
may be my whole "safe vs unsafe" framing itself. I know that many of
the ostensibly unsafe cases are in fact safe (with the right
infrastructure in place), because the MDAM paper says just that. The
optimizer can't support inequalities right now, but the paper
describes how to support "NOT IN( )" lists -- clearly an inequality!
The current ad-hoc rules are at best incomplete, and at worst are
addressing the problem in fundamentally the wrong way.

 CNF -> DNF conversion
=====================

Like many great papers, the MDAM paper takes one core idea, and finds
ways to leverage it to the hilt. Here the core idea is to take
predicates in conjunctive normal form (an "AND of ORs"), and convert
them into disjunctive normal form (an "OR of ANDs"). DNF quals are
logically equivalent to CNF quals, but ideally suited to SAOP-array
style processing by an ordered B-Tree index scan -- they reduce
everything to a series of non-overlapping primitive index scans, that
can be processed in keyspace order. We already do this today in the
case of SAOPs, in effect. The nbtree "next array keys" state machine
already materializes values that can be seen as MDAM style DNF single
value predicates. The state machine works by outputting the cartesian
product of each array as a multi-column index is scanned, but that
could be taken a lot further in the future. We can use essentially the
same kind of state machine to do everything described in the paper --
ultimately, it just needs to output a list of disjuncts, like the DNF
clauses that the paper shows in "Table 3".

In theory, anything can be supported via a sufficiently complete CNF
-> DNF conversion framework. There will likely always be the potential
for unsafe/unsupported clauses and/or types in an extensible system
like Postgres, though. So we will probably need to retain some notion
of safety. It seems like more of a job for nbtree preprocessing (or
some suitably index-AM-agnostic version of the same idea) than the
optimizer, in any case. But that's not entirely true, either (that
would be far too easy).

The optimizer still needs to optimize. It can't very well do that
without having some kind of advanced notice of what is and is not
supported by the index AM. And, the index AM cannot just unilaterally
decide that index quals actually should be treated as filter/qpquals,
after all -- it doesn't get a veto. So there is a mutual dependency
that needs to be resolved. I suspect that there needs to be a two way
conversation between the optimizer and nbtree code to break the
dependency -- a callback that does some of the preprocessing work
during planning. Tom said something along the same lines in passing,
when discussing the MDAM paper last year [2]. Much work remains here.

Skip Scan
=========

MDAM encompasses something that people tend to call "skip scan" --
terminology with a great deal of baggage. These days I prefer to call
it "filling in missing key predicates", per the paper. That's much
more descriptive, and makes it less likely that people will conflate
the techniques with InnoDB style "loose Index scans" -- the latter is
a much more specialized/targeted optimization. (I now believe that
these are very different things, though I was thrown off by the
superficial similarities for a long time. It's pretty confusing.)

I see this work as a key enabler of "filling in missing key
predicates". MDAM describes how to implement this technique by
applying the same principles that it applies everywhere else: it
proposes a scheme that converts predicates from CNF to DNF. With just
a little extra logic required to do index probes to feed the
DNF-generating state machine, on demand.

More concretely, in Postgres terms: skip scan can be implemented by
inventing a new placeholder clause that can be composed alongside
ScalarArrayOpExprs, in the same way that multiple ScalarArrayOpExprs
can be composed together in the patch already. I'm thinking of a type
of clause that makes the nbtree code materialize a set of "array keys"
for a SK_SEARCHARRAY scan key dynamically, via ad-hoc index probes
(perhaps static approaches would be better for types like boolean,
which the paper contemplates). It should be possible to teach the
_bt_advance_array_keys state machine to generate those values in
approximately the same fashion as it already does for
ScalarArrayOpExprs -- and, it shouldn't be too hard to do it in a
localized fashion, allowing everything else to continue to work in the
same way without any special concern. This separation of concerns is a
nice consequence of the way that the MDAM design really leverages
preprocessing/DNF for everything.

Both types of clauses can be treated as part of a general class of
ScalarArrayOpExpr-like clauses. Making the rules around
"composability" simple will be important.

Although skip scan gets a lot of attention, it's not necessarily the
most compelling MDAM technique. It's also not especially challenging
to implement on top of everything else. It really isn't that special.
Right now I'm focussed on the big picture, in any case. I want to
emphasize the very general nature of these techniques. Although I'm
focussed on SOAPs in the short term, many queries that don't make use
of SAOPs should ultimately see similar benefits. For example, the
paper also describes transformations that apply to BETWEEN/range
predicates. We might end up needing a third type of expression for
those. They're all just DNF single value predicates, under the hood.

Thoughts?

[1] http://vldb.org/conf/1995/P710.PDF
[2] https://www.postgresql.org/message-id/2587523.1647982549@sss.pgh.pa.us
[3] https://gist.github.com/benoittgt/ab72dc4cfedea2a0c6a5ee809d16e04d
--
Peter Geoghegan

--000000000000ceb32b060145ba56
Content-Type: application/octet-stream; 
	name="v1-0001-Enhance-nbtree-ScalarArrayOp-execution.patch"
Content-Disposition: attachment; 
	filename="v1-0001-Enhance-nbtree-ScalarArrayOp-execution.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_lkhm6m9g0>
X-Attachment-Id: f_lkhm6m9g0
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==
--000000000000ceb32b060145ba56--