MIME-Version: 1.0
From: Amit Langote <amitlangote09@gmail.com>
Date: Tue, 14 Apr 2026 17:19:44 +0900
Message-ID: 
 <CA+HiwqE1ntHy2h9zJ9v3MwAkoGAveSERcHWkDTTZnP0kxWqbKQ@mail.gmail.com>
Subject: GetCachedPlan() refactor: move execution lock acquisition out
To: PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="00000000000007e9a0064f6744b6"
Archived-At: 
 <https://www.postgresql.org/message-id/CA%2BHiwqE1ntHy2h9zJ9v3MwAkoGAveSERcHWkDTTZnP0kxWqbKQ%40mail.gmail.com>
Precedence: bulk

--00000000000007e9a0064f6744b6
Content-Type: text/plain; charset="UTF-8"

Over in the "generic plans and initial pruning" thread [1], I came to
think that the cleanest way to address the architectural issue behind
that thread is to make GetCachedPlan() do less execution-related work.
Specifically, it should stop acquiring execution locks itself, and
leave that decision to callers.

GetCachedPlan() has long combined plan acquisition with execution
setup, and that coupling makes it harder to improve either side
cleanly. Tom pointed in this direction back in 2023 [2]:

"...the whole problem arises because the system is wrongly factored.
We should get rid of AcquireExecutorLocks altogether, allowing the
plancache to hand back a generic plan that it's not certain of the
validity of, and instead integrate the responsibility for acquiring
locks into executor startup."

This patch takes the first half of that suggestion by moving execution
locking out of the plancache and into its callers.

The attached patch does that, with no intended behavioral change:

* Remove AcquireExecutorLocks() from CheckCachedPlan(), so
GetCachedPlan() returns a plan without holding execution locks.

* Add a new internal helper in plancache.c, LockCachedPlan(), which
acquires execution locks, rechecks validity, and returns false if the
plan was invalidated, so the caller can retry.

* Add GetCachedPlanLocked() as a convenience wrapper that fetches a
plan, calls LockCachedPlan(), and retries on invalidation. This
becomes the normal entry point for callers that want a plan ready for
execution.

* Convert existing GetCachedPlan() callers to use GetCachedPlanLocked().

The second half of Tom's suggestion, moving that responsibility into
executor startup, is trickier. ExecutorStart() is a stable API with
extension hooks, so changing its contract has a fairly high bar. I
tried that route once already [3].

A working variant that adds an ExecutorPrep() entry point, with a
wrapper implementing pruning-aware locking on top, was discussed in
the original thread [1].  But rather than propose that whole stack at
once, I think it is better to do this in phases: first decouple plan
acquisition from execution locking, then revisit the ExecutorPrep()
piece separately if this goes in.

The eventual goal is still pruning-aware locking. I'm posting this
piece separately because the original thread has become fairly long,
and this part seems easier to review on its own.

[1] https://postgr.es/m/CA+HiwqFGkMSge6TgC9KQzde0ohpAycLQuV7ooitEEpbKB0O_mg@mail.gmail.com
[2] https://postgr.es/m/4191508.1674157166%40sss.pgh.pa.us
[3] https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=1722d5eb05d8e5d2e064cd1798abcae4f296ca9d

--
Thanks, Amit Langote

--00000000000007e9a0064f6744b6
Content-Type: application/octet-stream;
	name="v1-0001-Move-execution-lock-acquisition-out-of-GetCachedP.patch"
Content-Disposition: attachment;
	filename="v1-0001-Move-execution-lock-acquisition-out-of-GetCachedP.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mnyba2g70>
X-Attachment-Id: f_mnyba2g70
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--00000000000007e9a0064f6744b6--