MIME-Version: 1.0
References: <CA+HiwqF4C0ws3cO+z5cLkPuvwnAwkSp7sfvgGj3yQ=Li6KNMqA@mail.gmail.com>
 <CA+HiwqGM6nvAV5O+=Nr+BXMPWOma0oeCRVzVP0XiLE8zX5TVAg@mail.gmail.com>
 <CA+HiwqGMaovCUgDbGxVGnK0Mrivr+ph3YE2Ws+47-ugyPb4f7g@mail.gmail.com>
 <CAFj8pRDaiBe_GOLk_yyYHTtPiDAAaLOM8u1-=Q3ZgXBTH+1igg@mail.gmail.com>
 <CA+HiwqGA5Ay_MR0eJEEbt4j6WrVh4F+AasTp8yCbs5aJLOJn6Q@mail.gmail.com>
 <CAEG8a3JM=NoqiTK0V6S9FNxZPvy1+C5F7rfafTtPKBVWnunL-g@mail.gmail.com>
 <CA+HiwqEyiLCY6MTLbOJXDdLNNQLaURYHvdW797MQgbjEK9od4Q@mail.gmail.com> <CAEG8a3+VBpwPf1Rm-ECD90whM9b3YnGhux5CVXdsL6khiBfzRQ@mail.gmail.com>
In-Reply-To: <CAEG8a3+VBpwPf1Rm-ECD90whM9b3YnGhux5CVXdsL6khiBfzRQ@mail.gmail.com>
From: Amit Langote <amitlangote09@gmail.com>
Date: Sat, 28 Feb 2026 16:08:05 +0900
Message-ID: <CA+HiwqF2UHzF0sKCp-F2a-U29rqh_9ZPy=f1h+Fh_=M8efj3pg@mail.gmail.com>
Subject: Re: Eliminating SPI / SQL from some RI triggers - take 3
To: Junwang Zhao <zhjwpku@gmail.com>
Cc: Pavel Stehule <pavel.stehule@gmail.com>, 
	PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000f8fbaf064bdd0411"
Archived-At: <https://www.postgresql.org/message-id/CA%2BHiwqF2UHzF0sKCp-F2a-U29rqh_9ZPy%3Df1h%2BFh_%3DM8efj3pg%40mail.gmail.com>
Precedence: bulk

--000000000000f8fbaf064bdd0411
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi Junwang,

On Mon, Feb 23, 2026 at 10:45=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com> w=
rote:
> On Thu, Feb 19, 2026 at 5:21=E2=80=AFPM Amit Langote <amitlangote09@gmail=
.com> wrote:
> > I re-ran the benchmarks (same test as yours, different machine):
> >
> > create table pk (a numeric primary key);
> > create table fk (a bigint references pk);
> > insert into pk select generate_series(1, 2000000);
> > insert into fk select generate_series(1, 2000000, 2);
> >
> > master: 2444 ms  (median of 3 runs)
> > 0001: 1382 ms  (43% faster)
> > 0001+0002: 1202 ms  (51% faster, 13% over 0001 alone)
>
> I can get similar improvement on my old mac intel chip:
>
> master: 12963.993 ms
> 0001: 6641.692 ms, 48.8% faster
> 0001+0002: 5771.703 ms, 55.5% faster
> >
> > Also, with int PK / int FK (1M rows):
> >
> > create table pk (a int primary key);
> > create table fk (a int references pk);
> > insert into pk select generate_series(1, 1000000);
> > insert into fk select generate_series(1, 1000000);
> >
> > master: 1000 ms
> > 0001: 520 ms  (48% faster)
> > 0001+0002: 432 ms  (57% faster, 17% over 0001 alone)
>
> master: 11134.583 ms
> 0001: 5240.298 ms, 52.9% faster
> 0001+0002: 4554.215 ms, 59.1% faster

Thanks for testing, good to see similar numbers.  I had forgotten to
note that these results are when these PK index probes don't do any
I/O, though you might be aware of that. Below, I report some numbers
that Tomas Vondra shared with me off-list where the probes do have to
perform I/O and there the benefits from only this patch set are only
marginal.

> I don't have any additional comments on the patch except one minor nit,
> maybe merge the following two if conditions into one, not a strong opinio=
n
> though.
>
> if (use_cache)
> {
> /*
> * The snapshot was registered once when the cache entry was created.
> * We just patch curcid to reflect the new command counter.
> * SnapshotSetCommandId() only patches process-global statics, not
> * registered copies, so we do it directly.
> *
> * The xmin/xmax/xip fields don't need refreshing: within a single
> * statement batch, only curcid changes between rows.
> */
> Assert(fpentry && fpentry->snapshot !=3D NULL);
> snapshot =3D fpentry->snapshot;
> snapshot->curcid =3D GetCurrentCommandId(false);
> }
> else
> snapshot =3D RegisterSnapshot(GetLatestSnapshot());
>
> if (use_cache)
> {
> pk_rel =3D fpentry->pk_rel;
> idx_rel =3D fpentry->idx_rel;
> scandesc =3D fpentry->scandesc;
> slot =3D fpentry->slot;
> }
> else
> {
> pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> idx_rel =3D index_open(riinfo->conindid, AccessShareLock);
> scandesc =3D index_beginscan(pk_rel, idx_rel,
> snapshot, NULL,
> riinfo->nkeys, 0);
> slot =3D table_slot_create(pk_rel, NULL);
> }

Good idea, done.

While polishing 0002, I revisited the snapshot caching semantics. The
previous commit message hand-waved about only curcid changing between
rows, but GetLatestSnapshot() also reflects other backends' commits,
so reusing the snapshot is a deliberate semantic change from the SPI
path. I think it's safe because curcid is all we need for
intra-statement visibility, concurrent commits either already happened
before our snapshot (and are visible) or are racing with our statement
and wouldn't be seen reliably even with per-row snapshots since the
order in which FK rows are checked is nondeterministic, and
LockTupleKeyShare prevents the PK row from disappearing regardless. In
essence, we're treating all the FK checks within a trigger-firing
cycle as a single plan execution that happens to scan N rows, rather
than N independent SPI queries each taking a fresh snapshot. That's
the natural model -- a normal SELECT ... FOR KEY SHARE plan doesn't
re-take GetLatestSnapshot() between rows either.

Similarly, the permission check (schema USAGE + table SELECT) is now
done once at cache entry creation in ri_FastPathGetEntry() rather than
on every flush. The RI check runs as the PK table owner, so we're
verifying that the owner can access their own table -- a condition
that won't change unless someone explicitly revokes from the owner,
which would also break the SPI path.

> > David Rowley mentioned off-list that it might be worth batching
> > multiple FK values into a single index probe, leveraging the
> > ScalarArrayOp btree improvements from PostgreSQL 17. The idea would be
> > to buffer FK values across trigger invocations in the per-constraint
> > cache (0002 already has the right structure for this), build a
> > SK_SEARCHARRAY scan key, and let the btree AM walk the matching leaf
> > pages in one sorted traversal instead of one tree descent per row. The
> > locking and recheck would still be per-tuple, but the index traversal
> > cost drops significantly. Single-column FKs are the obvious starting
> > point. That seems worth exploring but can be done as a separate patch
> > on top of this.
>
> I will take a look at this in the following weeks.

I ended up going ahead with the batching and SAOP idea that David
mentioned -- I had a proof-of-concept working shortly after posting v3
and kept iterating on it.  So attached set is now:

0001 - Core fast path (your 0001+0002 reworked, as before)

0002 - Per-batch resource caching (PK relation, index, scandesc, snapshot)

0003 - FK row buffering: materialize FK tuples into a per-constraint
batch buffer (64 rows), flush when full or at batch end

0004 - SK_SEARCHARRAY for single-column FKs: build an array from the
buffered FK values and do one index scan instead of 64 separate tree
descents.  Multi-column FKs fall back to a per-row loop.

0003 is pure infrastructure -- it doesn't improve performance on its
own because the per-row index descent still dominates.  The payoff
comes in 0004.

Numbers (same machine as before, median of 3 runs):

numeric PK / bigint FK, 1M rows:
master: 2487 ms
0001..0004: 1168 ms  (2.1x)

int PK / int FK, 500K rows:
master: 1043 ms
0001..0004: 335 ms  (3.1x)

The int/int case benefits most because the per-row cost is lower, so
the SAOP traversal savings are a larger fraction of the total. The
numeric/bigint case still sees a solid improvement despite the
cross-type cast overhead.

Tomas Vondra also tested with an I/O-intensive workload (dataset
larger than shared_buffers, combined with his and Peter Geoghegan's
I/O prefetching patches) and confirmed that the batching + SAOP
approach helps there too, not just in the CPU-bound / memory-resident
case.  In fact he showed that the patches here don't make a big dent
when the main bottleneck is I/O as shown in numbers that he shared in
an off-list email:

master: 161617 ms
ri-check (0001..0004): 149446 ms  (1.08x)
ri-check + i/o prefetching: 50885 ms  (3.2x)

So the RI patches alone only give ~8% here since most time is waiting
on reads.  But the batching gives the prefetch machinery a window of
upcoming probes to issue readahead against, so the two together yield
3.2x.

Tomas also caught a memory context bug in the batch flush path: the
cached scandesc lives in TopTransactionContext, but the btree AM
defers _bt_preprocess_keys allocation to the first getnext call, which
pallocs into CurrentMemoryContext. If that's a short-lived
per-trigger-row context, the scandesc has dangling pointers on the
next rescan. Fixed by switching to TopTransactionContext before the
probe loop.

Finally, I've fixed a number of other small and not-so-small bugs
found while polishing the old patches and made other stylistic
improvements. One notable change is that I introduced a FastPathMeta
struct to store the fast path metadata instead of dumping those arrays
in the RI_ConstraintInfo. It's allocated lazily on first use and holds
the per-key compare entries, operator procedures, and index strategy
info needed by the scan key construction, so RI_ConstraintInfo doesn't
pay for them when the fast path isn't used.


On Mon, Feb 23, 2026 at 10:45=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com> w=
rote:
>
> Hi Amit,
>
> On Thu, Feb 19, 2026 at 5:21=E2=80=AFPM Amit Langote <amitlangote09@gmail=
.com> wrote:
> >
> > Hi Junwang,
> >
> > On Mon, Dec 1, 2025 at 3:09=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com>=
 wrote:
> > > As Amit has already stated, we are approaching a hybrid "fast-path + =
fallback"
> > > design.
> > >
> > > 0001 adds a fast path optimization for foreign key constraint checks
> > > that bypasses the SPI executor, the fast path applies when the refere=
nced
> > > table is not partitioned, and the constraint does not involve tempora=
l
> > > semantics.
> > >
> > > With the following test:
> > >
> > > create table pk (a numeric primary key);
> > > create table fk (a bigint references pk);
> > > insert into pk select generate_series(1, 2000000);
> > >
> > > head:
> > >
> > > [local] zhjwpku@postgres:5432-90419=3D# insert into fk select
> > > generate_series(1, 2000000, 2);
> > > INSERT 0 1000000
> > > Time: 13516.177 ms (00:13.516)
> > >
> > > [local] zhjwpku@postgres:5432-90419=3D# update fk set a =3D a + 1;
> > > UPDATE 1000000
> > > Time: 15057.638 ms (00:15.058)
> > >
> > > patched:
> > >
> > > [local] zhjwpku@postgres:5432-98673=3D# insert into fk select
> > > generate_series(1, 2000000, 2);
> > > INSERT 0 1000000
> > > Time: 8248.777 ms (00:08.249)
> > >
> > > [local] zhjwpku@postgres:5432-98673=3D# update fk set a =3D a + 1;
> > > UPDATE 1000000
> > > Time: 10117.002 ms (00:10.117)
> > >
> > > 0002 cache fast-path metadata used by the index probe, at the current
> > > time only comparison operator hash entries, operator function OIDs
> > > and strategy numbers and subtypes for index scans. But this cache
> > > doesn't buy any performance improvement.
> > >
> > > Caching additional metadata should improve performance for foreign ke=
y checks.
> > >
> > > Amit suggested introducing a mechanism for ri_triggers.c to register =
a
> > > cleanup callback in the EState, which AfterTriggerEndQuery() could th=
en
> > > invoke to release per-statement cached metadata (such as the IndexSca=
nDesc).
> > > However, I haven't been able to implement this mechanism yet.
> >
> > Thanks for working on this.  I've taken your patches as a starting
> > point and reworked the series into two patches (attached): 1st is your
> > 0001+0002 as the core patch that adds a gated fast-path alternative to
> > SPI and 2nd where I added per-statement resource caching.  Doing the
> > latter turned out to be not so hard thanks to the structure you chose
> > to build the core fast path.  Good call on adding the RLS and ACL test
> > cases, btw.
> >
> > So, 0001 is a functionally complete fast path: concurrency handling,
> > REPEATABLE READ crosscheck, cross-type operators, security context,
> > and metadata caching. 0002 implements the per-statement resource
> > caching we discussed, though instead of sharing the EState between
> > trigger.c and ri_triggers.c it uses a new AfterTriggerBatchCallback
> > mechanism that fires at the end of each trigger-firing cycle
> > (per-statement for immediate constraints, or until COMMIT for deferred
> > ones). It layers resource caching on top so that the PK relation,
> > index, scan descriptor, and snapshot stay open across all FK trigger
> > invocations within a single trigger-firing cycle rather than being
> > opened and closed per row.
> >
> > Note that phe previous 0002 (metadata caching) is folded into 0001,
> > and most of the new fast-path logic added in 0001 now lives in
> > ri_FastPathCheck() rather than inline in RI_FKey_check(), so the
> > RI_FKey_check diff is just the gating call and SPI fallback.
> >
> > I re-ran the benchmarks (same test as yours, different machine):
> >
> > create table pk (a numeric primary key);
> > create table fk (a bigint references pk);
> > insert into pk select generate_series(1, 2000000);
> > insert into fk select generate_series(1, 2000000, 2);
> >
> > master: 2444 ms  (median of 3 runs)
> > 0001: 1382 ms  (43% faster)
> > 0001+0002: 1202 ms  (51% faster, 13% over 0001 alone)
>
> I can get similar improvement on my old mac intel chip:
>
> master: 12963.993 ms
> 0001: 6641.692 ms, 48.8% faster
> 0001+0002: 5771.703 ms, 55.5% faster
>
> >
> > Also, with int PK / int FK (1M rows):
> >
> > create table pk (a int primary key);
> > create table fk (a int references pk);
> > insert into pk select generate_series(1, 1000000);
> > insert into fk select generate_series(1, 1000000);
> >
> > master: 1000 ms
> > 0001: 520 ms  (48% faster)
> > 0001+0002: 432 ms  (57% faster, 17% over 0001 alone)
>
> master: 11134.583 ms
> 0001: 5240.298 ms, 52.9% faster
> 0001+0002: 4554.215 ms, 59.1% faster
>
> >
> > The incremental gain from 0002 comes from eliminating per-row relation
> > open/close, scan begin/end, slot alloc/free, and replacing per-row
> > GetSnapshotData() with only curcid adjustment on the registered
> > snapshot copy in the cache.
> >
> > The two current limitations are partitioned referenced tables and
> > temporal foreign keys. Partitioned PKs are relatively uncommon in
> > practice, so the non-partitioned case should cover most FK workloads,
> > so I'm not sure it's worth the added complexity to support them.
> > Temporal FKs are inherently multi-row, so they're a poor fit for a
> > single-probe fast path.
> >
> > David Rowley mentioned off-list that it might be worth batching
> > multiple FK values into a single index probe, leveraging the
> > ScalarArrayOp btree improvements from PostgreSQL 17. The idea would be
> > to buffer FK values across trigger invocations in the per-constraint
> > cache (0002 already has the right structure for this), build a
> > SK_SEARCHARRAY scan key, and let the btree AM walk the matching leaf
> > pages in one sorted traversal instead of one tree descent per row. The
> > locking and recheck would still be per-tuple, but the index traversal
> > cost drops significantly. Single-column FKs are the obvious starting
> > point. That seems worth exploring but can be done as a separate patch
> > on top of this.
>
> I will take a look at this in the following weeks.
>
> >
> > I think the series is in reasonable shape but would appreciate extra
> > eyeballs, especially on the concurrency handling in ri_LockPKTuple()
> > in 0001 and the snapshot lifecycle in 0002. Or anything else that
> > catches one's eye.
> >
> > --
> > Thanks, Amit Langote
>
> I don't have any additional comments on the patch except one minor nit,
> maybe merge the following two if conditions into one, not a strong opinio=
n
> though.
>
> if (use_cache)
> {
> /*
> * The snapshot was registered once when the cache entry was created.
> * We just patch curcid to reflect the new command counter.
> * SnapshotSetCommandId() only patches process-global statics, not
> * registered copies, so we do it directly.
> *
> * The xmin/xmax/xip fields don't need refreshing: within a single
> * statement batch, only curcid changes between rows.
> */
> Assert(fpentry && fpentry->snapshot !=3D NULL);
> snapshot =3D fpentry->snapshot;
> snapshot->curcid =3D GetCurrentCommandId(false);
> }
> else
> snapshot =3D RegisterSnapshot(GetLatestSnapshot());
>
> if (use_cache)
> {
> pk_rel =3D fpentry->pk_rel;
> idx_rel =3D fpentry->idx_rel;
> scandesc =3D fpentry->scandesc;
> slot =3D fpentry->slot;
> }
> else
> {
> pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> idx_rel =3D index_open(riinfo->conindid, AccessShareLock);
> scandesc =3D index_beginscan(pk_rel, idx_rel,
> snapshot, NULL,
> riinfo->nkeys, 0);
> slot =3D table_slot_create(pk_rel, NULL);
> }
>
> --
> Regards
> Junwang Zhao


--=20
Thanks, Amit Langote

--000000000000f8fbaf064bdd0411
Content-Type: application/octet-stream; 
	name="0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Disposition: attachment; 
	filename="0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mm5zbfct0>
X-Attachment-Id: f_mm5zbfct0
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--000000000000f8fbaf064bdd0411
Content-Type: application/octet-stream; 
	name="0004-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probes.patch"
Content-Disposition: attachment; 
	filename="0004-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probes.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mm5zbfdd3>
X-Attachment-Id: f_mm5zbfdd3
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--000000000000f8fbaf064bdd0411
Content-Type: application/octet-stream; 
	name="0003-Buffer-FK-rows-for-batched-fast-path-probing.patch"
Content-Disposition: attachment; 
	filename="0003-Buffer-FK-rows-for-batched-fast-path-probing.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mm5zbfd82>
X-Attachment-Id: f_mm5zbfd82
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--000000000000f8fbaf064bdd0411
Content-Type: application/octet-stream; 
	name="0002-Cache-per-batch-resources-for-fast-path-foreign-key-.patch"
Content-Disposition: attachment; 
	filename="0002-Cache-per-batch-resources-for-fast-path-foreign-key-.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mm5zbfd21>
X-Attachment-Id: f_mm5zbfd21
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==
--000000000000f8fbaf064bdd0411--