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>
 <CA+HiwqF2UHzF0sKCp-F2a-U29rqh_9ZPy=f1h+Fh_=M8efj3pg@mail.gmail.com>
 <CAEG8a3L9Ew-WL8sxLROVOcypeaENPmd8qCmMvz4geoGL1TDGCA@mail.gmail.com>
 <CAEG8a3+nUFQo4sdPQF9xy0J73J8RFJ5U9A5+_kMosGDaZ+1sXA@mail.gmail.com>
 <2BE661BA-D909-4093-BF78-DB9B0C099337@gmail.com>
In-Reply-To: <2BE661BA-D909-4093-BF78-DB9B0C099337@gmail.com>
From: Junwang Zhao <zhjwpku@gmail.com>
Date: Wed, 18 Mar 2026 23:34:30 +0800
Message-ID: 
 <CAEG8a3JyKdizWvYsF+z_mA1BKy=dpW11iKVMOG=bk6Tbz6M1Bw@mail.gmail.com>
Subject: Re: Eliminating SPI / SQL from some RI triggers - take 3
To: Haibo Yan <tristan.yim@gmail.com>
Cc: amitlangote09@gmail.com, Pavel Stehule <pavel.stehule@gmail.com>,
	PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000e8c4ab064d4e306d"
Archived-At: 
 <https://www.postgresql.org/message-id/CAEG8a3JyKdizWvYsF%2Bz_mA1BKy%3DdpW11iKVMOG%3Dbk6Tbz6M1Bw%40mail.gmail.com>
Precedence: bulk

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

Hi Haibo,

On Tue, Mar 17, 2026 at 8:28=E2=80=AFAM Haibo Yan <tristan.yim@gmail.com> w=
rote:
>
> Hi, Amit and Junwang
>
> Thanks for the latest patch. I think the overall direction makes sense, a=
nd the single-column SK_SEARCHARRAY path looks like one of the most valuabl=
e optimizations here. The patch also seems to cover several important cases=
, including deferred constraints, duplicate FK values, and multi-column fal=
lback behavior.
>
> After reading through the patch, I have one major comments and a few smal=
ler ones.

Thanks for your review.

>
> 1. TopTransactionContext usage during batched flush may be too coarse-gra=
ined
> My biggest concern is the use of TopTransactionContext around the batched=
 flush path.
> As written, ri_FastPathBatchFlush() switches to TopTransactionContext bef=
ore calling ri_FastPathFlushArray() / ri_FastPathFlushLoop(). That seems br=
oad enough that temporary allocations made during the flush may end up ther=
e.
> In particular, in ri_FastPathFlushArray(), I think the objects worth chec=
king carefully are the pass-by-reference Datums returned by the per-element=
 cast call and stored in search_vals[], e.g.
>
> ```search_vals[i] =3D FunctionCall3(&entry->cast_func_finfo, ...);```
> If those cast results are separately allocated in the current memory cont=
ext, then pfree(arr) only frees the constructed array object itself; it doe=
s not obviously free those intermediate cast results. If so, those allocati=
ons could survive until end of transaction rather than just until the end o=
f the current flush.
> Maybe this is harmless in practice, but I think it needs a closer look. I=
t might be better to use a dedicated short-lived context for per-flush temp=
orary allocations, reset it after each flush, or otherwise separate allocat=
ions that really need transaction lifetime from those that are only needed =
transiently during batched processing.

Yeah, that concern is reasonable. After a brief discussion with Amit,
we now replace the TopTransactionContext usage with two
purpose-specific contexts, scan_cxt for index AM allocations, freed
at teardown, and flush_cxt for per-flush transient work, reset each flush,
TopTransactionContext is parent of scan_cxt, and scan_cxt is parent
of flush_cxt, so MemoryContextDelete(scan_cxt) in teardown cleans up
both.

These changes are in v7-0004.

>
> 2. RI_FastPathEntry comment mentions the wrong function name
> The comment above RI_FastPathEntry says it contains resources needed by r=
i_FastPathFlushBatch(), but the function is named ri_FastPathBatchFlush().

Fixed.

>
> 3. RI_FASTPATH_BATCH_SIZE needs some rationale
> RI_FASTPATH_BATCH_SIZE =3D 64 may well be a reasonable compromise, but ri=
ght now it reads like a magic number.
> This choice seems especially relevant because the patch has two opposing =
effects:
> 3-1. larger batches should amortize the array-scan work better,
> 3-2. but the matched[] bookkeeping in ri_FastPathFlushArray() is O(batch_=
size^2) in the worst case.
> So I think it would help to include at least a brief rationale in a comme=
nt or in the commit message.

Added.

>
> 4. Commit message says the entry stashes fk_relid, but the code actually =
stashes riinfo
> The commit message says the entry stashes fk_relid and can reopen the rel=
ation if needed. Unless I am misreading it, the code actually stores riinfo=
 and later uses riinfo->fk_relid. The distinction is small, but I think the=
 wording should match the implementation more closely.

I changed the commit message to:

Since the FK relation may already be closed by flush time (e.g. for
deferred constraints at COMMIT), reopens the relation using
entry->riinfo->fk_relid if needed.

>
> Thanks again for working on this.
>
> Best regards,
>
> Haibo Yan
>
>
> On Mar 10, 2026, at 5:28=E2=80=AFAM, Junwang Zhao <zhjwpku@gmail.com> wro=
te:
>
> Hi,
>
> On Mon, Mar 2, 2026 at 11:30=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com> =
wrote:
>
>
> On Sat, Feb 28, 2026 at 3:08=E2=80=AFPM Amit Langote <amitlangote09@gmail=
.com> wrote:
>
>
> Hi Junwang,
>
> On Mon, Feb 23, 2026 at 10:45=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com>=
 wrote:
>
> 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.
>
>
> nice improvement.
>
> 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.
>
>
> impressive!
>
>
> 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
>
>
> Yeah, this is much better than the fpmeta_valid field.
>
> 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>=
 wrote:
>
>
> 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> w=
rote:
>
> As Amit has already stated, we are approaching a hybrid "fast-path + fall=
back"
> design.
>
> 0001 adds a fast path optimization for foreign key constraint checks
> that bypasses the SPI executor, the fast path applies when the referenced
> table is not partitioned, and the constraint does not involve temporal
> 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 key ch=
ecks.
>
> Amit suggested introducing a mechanism for ri_triggers.c to register a
> cleanup callback in the EState, which AfterTriggerEndQuery() could then
> invoke to release per-statement cached metadata (such as the IndexScanDes=
c).
> 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
>
>
>
>
> --
> Thanks, Amit Langote
>
>
>
>
> --
> Regards
> Junwang Zhao
>
>
> I had an offline discussion with Amit today. There were a few small thing=
s
> that could be improved, so I posted a new version of the patch set.
>
> 1.
>
> + if (ri_fastpath_is_applicable(riinfo))
> + {
> + bool found =3D ri_FastPathCheck(riinfo, fk_rel, newslot);
> +
> + if (found)
> + return PointerGetDatum(NULL);
> +
> + /*
> + * ri_FastPathCheck opens pk_rel internally; we need it for
> + * ri_ReportViolation.  Re-open briefly.
> + */
> + pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> + ri_ReportViolation(riinfo, pk_rel, fk_rel,
> +    newslot, NULL,
> +    RI_PLAN_CHECK_LOOKUPPK, false, false);
> + }
>
> Move ri_ReportViolation into ri_FastPathCheck, so table_open is no
> longer needed, and ri_FastPathCheck now returns void. Since Amit
> agreed this is the right approach, I included it directly in v5-0001.
>
> 2.
>
> After adding the batch fast path, the original ri_FastPathCheck is only
> used by the ALTER TABLE validation path. This path cannot use the
> cache because the registered AfterTriggerBatch callback will never run.
> Therefore, the use_cache branch can be removed.
>
> I made this change in v5-0004 and also updated some related comments.
> Once we agree the changes are correct, it can be merged into v5-0003.
>
> 3.
>
> + fk_slot =3D MakeSingleTupleTableSlot(RelationGetDescr(fk_rel),
> +    &TTSOpsHeapTuple);
>
> ri_FastPathBatchFlush creates a new fk_slot but does not cache it in
> RI_FastPathEntry. I tried caching it in v5-0006 and ran some benchmarks,
> it didn't show much improvement. This might be because the slot creation
> function is called once per batch rather than once per row, so the overal=
l
> impact is minimal. I'm posting this here for Amit to take a look and deci=
de
> whether we should adopt it or drop it, since I mentioned the idea to
> him earlier.
>
> 4.
>
> ri_FastPathFlushArray currently uses SK_SEARCHARRAY only for
> single-column checks. I asked whether this could be extended to support
> multi-column cases, and Amit encouraged me to look into it.
>
> After a brief investigation, it seems that ScanKeyEntryInitialize only al=
lows
> passing a single subtype/collation/procedure, which makes it difficult to
> handle multiple types. Based on this, my current understanding is that
> SK_SEARCHARRAY may not work for multi-column checks.
>
> --
> Regards
> Junwang Zhao
> <v5-0005-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probe.patch><v5-0006=
-Reuse-FK-tuple-slot-across-fast-path-batches.patch><v5-0002-Cache-per-batc=
h-resources-for-fast-path-foreign-k.patch><v5-0004-Refine-fast-path-FK-vali=
dation-path.patch><v5-0003-Buffer-FK-rows-for-batched-fast-path-probing.pat=
ch><v5-0001-Add-fast-path-for-foreign-key-constraint-checks.patch>
>
>


--=20
Regards
Junwang Zhao

--000000000000e8c4ab064d4e306d
Content-Type: application/octet-stream;
	name="v7-0004-Refactor-RI-fast-path-to-use-scan_cxt-and-flush_c.patch"
Content-Disposition: attachment;
	filename="v7-0004-Refactor-RI-fast-path-to-use-scan_cxt-and-flush_c.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmw62aay0>
X-Attachment-Id: f_mmw62aay0
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==
--000000000000e8c4ab064d4e306d
Content-Type: application/octet-stream;
	name="v7-0003-Batch-FK-rows-and-use-SK_SEARCHARRAY-for-fast-pat.patch"
Content-Disposition: attachment;
	filename="v7-0003-Batch-FK-rows-and-use-SK_SEARCHARRAY-for-fast-pat.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmw62acj1>
X-Attachment-Id: f_mmw62acj1
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--000000000000e8c4ab064d4e306d
Content-Type: application/octet-stream;
	name="v7-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Disposition: attachment;
	filename="v7-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmw62adh2>
X-Attachment-Id: f_mmw62adh2
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--000000000000e8c4ab064d4e306d
Content-Type: application/octet-stream;
	name="v7-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Disposition: attachment;
	filename="v7-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmw62aeb3>
X-Attachment-Id: f_mmw62aeb3
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--000000000000e8c4ab064d4e306d--