Feedback-ID: i675e48f3:Fastmail
Date: Sun, 16 Nov 2025 13:53:09 -0500
From: Greg Burd <greg@burd.me>
To: "=?utf-8?Q?pgsql-hackers=40postgresql.org?="
 <pgsql-hackers@postgresql.org>
Message-ID: <BCF1BF66-7A1B-4E01-87DC-0BE45EDF2F98@greg.burd.me>
In-Reply-To: <ea98b11380557874a7bf3a577146786df8ec1da1.camel@j-davis.com>
References: <ea98b11380557874a7bf3a577146786df8ec1da1.camel@j-davis.com>
Subject: Re: Expanding HOT updates for expression and partial indexes
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="691a1d95_1c3bff29_db0"
Archived-At: 
 <https://www.postgresql.org/message-id/BCF1BF66-7A1B-4E01-87DC-0BE45EDF2F98%40greg.burd.me>
Precedence: bulk

--691a1d95_1c3bff29_db0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

Hello again.

This idea started over a year ago for me while working on a project that
used JSONB and had horrible "bloat" with update times that were not
fantastic.  The root cause, expression indexes prevent HOT updates and
all indexes on JSONB are by definition, expressions.  That's the backstory.

The idea for the solution came from a patch [1] applied [2], then later
reverted [3], that basically evaluated the before/after tuple
expressions in heap_update() at the point where newbuff == buffer just
before deciding to use_hot_update or not.  When the evaluated
expressions produced equal results using a binary comparison the index
didn't need to be updated.  While this approach sorta worked, but it was
reverted for a few reasons, here's Tom's summary: "The problem here is
that [the code that checks for equality] thinks that the type of the
index column is identical to the type of the source datum for it, which
is not true for any opclass making use of the opckeytype property. [4]"

Still, expanding the domain of what might go HOT seems like a good goal
to me and it was at the heart of the issues I was facing on the project
using JSONB, so I kept at it.

The patches I've sent on this thread have evolved from that first idea. 
First they addressed the specific issue raised by Tom.  Then they
expanded to include partial indexes as well.  This worked, and I helped
to ship a fork of Postgres used this approach and solved customer issues
with the JSONB use case.  Customer experience was better, no unnecessary
index updates when indexed data wasn't modified meant no more heap/index
bloat and faster update times.  Vacuum could finally keep up and
performance and storage overhead was much better.

For this patch set v1 through v17 were essentially work that
refined/reworked that original approach, but there was a serious flaw
that I didn't fully appreciate until around v16/17.  I was evaluating
the expressions while holding a lock on the buffer page which a) expands
the time the lock is held, and b) opens the door to self-deadlock.  No bueno.

Then there was v18, a quick work-around for that.  I moved the call that
invokes the executor to the beginning of heap_update() before taking the
lock on the page.  To do this I had to find the set of updated
attributes, which I discovered was available in the executor as the
updated tuple is created.  This was a viable fix, but didn't really go
far enough and was a bit hackish IMO.  Jeff Davis and others challenged
me to move the work to identify what's changed into the executor and
clean it up.  I'm a sucker for a challenge.

More generally, this idea made sense.  While Postgres has many places
where logic is tightly coupled to the way the heap works this didn't
have to be one. To make this work I needed the update path in the
executor to be interested in:

a) knowing what columns were specified in the UPDATE statement and those
impacted by before/after triggers,
b) reducing that set to those attributes known to be both indexed and to
have changed value,
c) finding which of those (and possibly other) attributes that force new
index updates.

Why?  We'll, that code already exists in a few places and in some cases
is replicated; for (a) there is ExecGetAllUpdatedCols(), for (b)
HeapDetermineColumnsInfo() and index_unchanged_by_update().

An interesting thing to note is that HeapDetermineColumnsInfo() might
return a set that includes columns not returned by
ExecGetAllUpdatedCols() because HeapDetermineColumnsInfo() iterates over
all indexed attributes looking for changes and that might find an
indexed attribute that was changed by heap_modify_tuple() but not
knowable by ExecGetAllUpdatedCols().  This happens in tsvector code, see
tsvector_op.c tsvector_update_trigger() where if (update_needed)
heap_modify_tuple_by_cols().  That column isn't known to ExecGetAllUpdatedCols().

HeapDetermineColumnsInfo() is also critical when modifying catalog
tuples.  Catalog tuples are modified using either Form/GETSTRUCT or
values/nulls/replaces then using heap_modify_tuple() and calling into
CatalogTupleUpdate() which calls simple_heap_update() that calls
heap_update() where we find HeapDetermineColumnsInfo().  The interesting
thing here is that when modifying catalog tuples there is knowledge of
what attributes are changed, but that knowledge isn't preserved and
passed into CatalogTupleUpdate(), rather it is re-discovered in
HeapDetermineColumnsInfo().  That's how catalog tuples are able to take
the HOT path, they re-use that same logic.  There is a fix for that [5]
too (and I really hope that lands in master ASAP), but that's not the
subject of this thread.

HeapDetermineColumnsInfo() also helps inform a few other decisions in
heap_update(), but these have to happen after taking the buffer lock and
are very heap-specific, namely:

1. Do either the replica identity key attributes overlap with the
modified index attributes or do they need to be stored externally, this
is passed on to ExtractReplicaIdentity() to find out if we must augment
the WAL log or not.

2. Are there any modified indexed attributes that intersect with the
primary keys of the relation, if not lower the lock mode to enable
multixact to work.

HeapDetermineColumnsInfo() also takes a pragmatic approach to testing
for equality when looking for modified indexed attributes, it uses
datumIsEqual() which boils down to a simple memcmp() of the before/after
HeapTuple datum.  This is fine in most cases, but limits the scope of
what can be HOT.

Interestingly, this requirement of binary equality has leaked into other
parts of the code, namely nbtree's deduplication of TIDs on page split. 
That code uses binary equality as well.  A nbtree index with collation
for case insensitive must store both "A" and "a" despite those being
type-equal because they are not binary equivalent.  More on this later.

At this point, I had my sights set on HeapDetermineColumnsInfo().  I
felt that what it was doing should move into the executor, well as much
of that work as possible, and outside of the buffer lock.  This would
also open the door for removal of redundant code.  My thought was that
the table AM update API should have an additional argument, the
"modified indexed attributes" or "mix_attrs", passed in.

So, here we are at the door of v19... let's begin.

0001 - Reorganize heap update logic

This is preparatory work for the larger goal in that heap_update()
serves two masters: CatalogTupleUpdate()/simple_heap_update() and
heap_tuple_update() and in reality, they were different but needed most
of the same logic that happens at the start of heap_update().  This
patch splits that logic out and moves it into heap_tuple_update() and
simple_heap_update().  Functionally nothing changes.  That's the meat of
this patch.Reorganize heap update logic


0002 - Track changed indexed columns in the executor during UPDATEs

This is the first core set of changes, it doesn't expand HOT updates but
it does restructure where HeapDetermineColumnsInfo()'s core work happens.

A new function ExecCheckIndexedAttrsForChanges() in nodeModifyTable.c is
now responsible for checking for changes between Datum in the old/new
TupleTableSlots.  This is different from before in that we're not
checking the new HeapTuple Datum verses the HeapTuple we read from the
buffer page while holding the lock on that page.

An update starts off by reading the existing tuple using the table AM. 
Then a new updated tuple is created as the set of changes to the old. 
Then the new TupleTableSlot is the combination of the existing one we
just read and the changes we just recorded.  So, in the executor before
calling into the table AM's update function we have a pin on the buffer
and the before/after TupleTableSlots for this update.  So, I've put the
call to my new ExecCheckIndexedAttrsForChanges() function just before
calling table_tuple_update() and I've added the "mix_attrs" into that
call which get passed on to the heap in heap_tuple_update() and then
heap_update() and all is well.

Why is this safe?  The way I read heap_update() is that it has always
historically had code to deal with cases where the tuple is concurrently
updated and react accordingly thanks to HeapTupleSatisfiesUpdate() which
remains where it was in heap_update(). Visibility checks happened when
we first read the tuple to form the updated tuple and later in
heap_update() when we call HeapTupleSatisfiesVisibility() to check for
transaction-snapshot mode RI updates.

So, this new update path from the executor into the table AM seems to me
to be okay and almost functionally equivalent.  But there is one big
change to discuss before moving to the simple_heap_update() path.

In nodeModifyTable.c tts_attr_equal() replaces heap_attr_equal()
changing the test for equality when calling into heap_tuple_update(). 
In the past we used datumIsEqual(), essentially a binary comparison
using memcmp(), now the comparison code in tts_attr_equal uses
type-specific equality function when available and falls back to
datumIsEqual() when not.

The other parts of HeapDetermineColumnsInfo() remain in the code, but
they still happen within the simple_heap_update() and
heap_tuple_update() code.  That's where you'll find that after the
buffer is locked we do (1) and (2) from above.  This keeps the
heap-specific work in the heap, but we've moved some work up into the
executor and outside the buffer lock.

While this accomplishes the goal of removing HeapDetermineColumnsInfo()
from heap_update() on the path that uses the table AM API
heap_tuple_update() but it doesn't on the simple_heap_update() path. 
That remains the same as it was in the previous patch.  Ideally, my
patch to restructure how catalog tuples are updated [5] is committed and
we can fully remove HeapDetermineColumnsInfo() and likely speed up all
catalog updates in the process.  That's what motivated [5], please take
a look, it required a huge number of changes so I thought it deserved a
life/thread of its own.

Finally, there is the ExecSimpleRelationUpdate() path and
slot_modify_data().  On this path we know what attributes are being
updated, so we just check to see if they changed and then intersect that
with the set of indexed attributes and we have our modified indexed
attributes set to pass into simple_heap_update().

0003 - Replace index_unchanged_by_update with ri_ChangedIndexedCols

This patch removes the function index_unchanged_by_update() in
execIndexing.c and simply re-uses the modified indexed attributes that
we've stashed away in ResultRelInfo as ri_ChangedIndexedCols.  This
provides a hint when calling into the index AM's index_insert() function
indicating if the UPDATE was without logical change to the data or not. 
We've done that check, we don't need to do it again.


0004 - Enable HOT updates for expression and partial indexes

This finally gets us back to where this project started, but on much
more firm ground than before because we're not going to self-deadlock. 
The idea has grown from a small function into something larger, but only
out of necessity.

In this patch I add ExecWhichIndexesRequireUpdates() in execIndexing.c
which implements (c) finding the set of attributes that force new index
updates.  This set can be very different from the modified indexed
attributes.  We know that some attributes are not equal to their
previous versions, but does that mean that the index that references
that attribute needs a new index tuple?  It may, or it may not.  Here's
the comment on that function that explains:

/*
 * ExecWhichIndexesRequireUpdates
 *
 * Determine which indexes need updating given modified indexed attributes.
 * This function is a companion to ExecCheckIndexedAttrsForChanges(). 
On the
 * surface, they appear similar but they are doing two very different things.
 *
 * For a standard index on a set of attributes this is the intersection of
 * the mix_attrs and the index attrs (key, expression, but not predicate).
 *
 * For expression indexes and indexes which implement the amcomparedatums()
 * index AM API we'll need to form index datum and compare each
attribute to
 * see if any actually changed.
 *
 * For expression indexes the result of the expression might not change
at all,
 * this is common with JSONB columns which require expression indexes
and where
 * it is commonplace to index a field within a document and have updates that
 * generally don't update that field.
 *
 * Partial indexes won't trigger index tuples when the old/new tuples
are both
 * outside of the predicate range.
 *
 * For nbtree the amcomparedatums() API is critical as it requires that key
 * attributes are equal when they memcmp(), which might not be the case when
 * using type-specific comparison or factoring in collation which might make
 * an index case insensitive.
 *
 * All of this is to say that the goal is for the executor to know,
ahead of
 * calling into the table AM for the update and before calling into the index
 * AM for inserting new index tuples, which attributes at a minimum will
 * necessitate a new index tuple.
 *
...
 */

Whereas before we were comparing Datum in the table relation, now we're
comparing Datum in the index relation.  Index AMs are free to store what
they want, we need to know if what's changed and referenced by the index
means that the index needs a new tuple or not.

In the case of a JSONB expression index (or any expression index) the
expression is evaluated when calling FormIndexDatum().  The result of
the expression is the Datum in the values/isnull arrays.  Then we need
to compare them to see if they changed.  This can be done using the same
tts_attr_equal() function, but with the attribute desc of the index, not
table relation.

In some cases that's not enough, for instance nbtree and it's more
stringent equality requirements.  For that reason (and another coming up
in a second) we need a new optional index AM API, amcomparedatums(). 
Indexes implementing this function have the ability to compare two
Datums for equality in what ever way they want.  For nbtree, that's a
binary comparison.

The new case here that this also supports is for indexes like GIN/RUM
where there is an opclass that can extract zero or more pieces from the
attribute and form multiple index entries when needed.  Those extracted
pieces might have odd equality rules as well.  This opens the door for
index implementations to provide information that will help inform heap
when making HOT decisions that didn't exist before.

Take for example the Linux Foundation's DocumentDB [6] project [7] which
aims to be an open source alternative to MongoDB built on top of
PostgreSQL.  One of the pieces of that project is its "extended RUM"
index AM implementation.  This index extracts portions of the BSON
documents stored and forms index keys from that.  Here is an example:

CREATE INDEX documents_rum_index_14002
ON documentdb_data.documents_14001
USING documentdb_rum
  (document bson_rum_single_path_ops (path=a, iswildcard='true', tl='2699'))

An index on the "document" column which uses the
"bson_rum_single_path_ops" opclass to extract a portion of the BSON
document that matches "path=a".

For this to potentially be stored by heap as a HOT update we need to
know that what changed within that document didn't intersect with the
"path=a" and if it did that the new value(s) were all equal to the old
values.  Equality in DocumentDB isn't what you think, it's quite odd and
specific to BSON and rules defined by MongoDB so it's important to allow
the index AM to execute what's necessary for it's use case.

For the more common JSONB use case we can now have heap make an informed
decision  about HOT updates after evaluating the expression.  For
GIN/RUM/etc. implementation there is a path to HOT.  For nbtree there is
a way to maintain its requirements.

Is there a cost to all this?  Yes, of course.  There is net new work
being done on some paths.  IndexFormDatum() will be called more
frequently and sometimes twice for the same thing.  This could be
improved, there might be a way to cache that information.  But to have
tests of old/new we'll have to do that work at least twice.

Is there a benefit?  Yes, of course.  Some redundant code paths are gone
and in the end we've increased the number of cases where HOT updates are
a possibility.  This  especially helps out users of JSONB, but not only them.

What's left undone?

* I need to check code coverage so that I might
* create tests covering all the new cases
* update the README.HOT documentation, wiki, etc.
* performance...

For performance I'd like to examine some worst cases as in lots of
indexes that have a lot of new code to exercise and all but the last
index would allow for a HOT update.  That should represent the maximum
amount of new overhead for this code.  Then, the other side of the
equation, how much does this help JSONB?  I think that is something to
measure in terms of TPS as well as "bloat" avoided and time spent vacuuming.

I also don't like the TU_Updating enum, I think it's a leaky abstraction
and really pointless now.  I'd like to remove it in favor of the bitmap
of attributes known to force index tuples to be inserted.  Maybe I'll
layer that into the next set.

In the end, this is a lot of work and I believe that it moves the ball
forward.  I'll have more metrics on that soon I hope, but I wanted to
get the conversation re-started ASAP as we're late in the v19 cycle.

Finally, the "elephant" in the room (ha!) is PHOT[9]/WARM[10][11].  Yes,
some of this work does help make a solution to allow HOT updates when
only updating a subset of indexes closer to reality, I'd be lying not to
mention that here, it is a big part of my overall plan for my next year
and (I hope) v20 and I need this work to get there.  Specifically, PHOT
is in part based on HeapDetermineColumnsInfo() and I needed to make that
more truthful for it to work.

I hope you see the value in this work and will partner with me to
finalize it and get it into master.

best.

-greg

[1] https://www.postgresql.org/message-id/flat/4d9928ee-a9e6-15f9-9c82-5981f13ffca6%40postgrespro.ru
[2] https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=c203d6cf8
[3] https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=05f84605dbeb9cf8279a157234b24bbb706c5256
[4] https://www.postgresql.org/message-id/2877.1541538838%40sss.pgh.pa.us
[5] https://www.postgresql.org/message-id/flat/2C5C8B8D-8B36-4547-88EB-BDCF9A7C8D94@greg.burd.me
[6] https://www.linuxfoundation.org/press/linux-foundation-welcomes-documentdb-to-advance-open-developer-first-nosql-innovation
[7] https://github.com/documentdb/documentdb
[8] https://github.com/documentdb/documentdb/tree/main/pg_documentdb_extended_rum
[9] https://www.postgresql.org/message-id/flat/2ECBBCA0-4D8D-4841-8872-4A5BBDC063D2%40amazon.com
[10] https://www.postgresql.org/message-id/flat/CABOikdMop5Rb_RnS2xFdAXMZGSqcJ-P-BY2ruMd%2BbuUkJ4iDPw%40mail.gmail.com
[11]
https://www.postgresql.org/message-id/flat/CABOikdMNy6yowA%2BwTGK9RVd8iw%2BCzqHeQSGpW7Yka_4RSZ_LOQ%40mail.gmail.com
--691a1d95_1c3bff29_db0
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="v19-0001-Reorganize-heap-update-logic.patch"
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--691a1d95_1c3bff29_db0
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="v19-0002-Track-changed-indexed-columns-in-the-executor-du.patch"
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--691a1d95_1c3bff29_db0
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="=?utf-8?Q?v19-0003-Replace-index=5Funchanged=5Fby=5Fupdate-with-ri=5FChange.patch?="
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--691a1d95_1c3bff29_db0
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="v19-0004-Enable-HOT-updates-for-expression-and-partial-in.patch"
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--691a1d95_1c3bff29_db0--