public inbox for [email protected]
help / color / mirror / Atom feedRe: PG 16 draft release notes ready
9+ messages / 2 participants
[nested] [flat]
* Re: PG 16 draft release notes ready
@ 2023-05-21 23:51 Jonathan S. Katz <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Jonathan S. Katz @ 2023-05-21 23:51 UTC (permalink / raw)
To: Andres Freund <[email protected]>; Bruce Momjian <[email protected]>; +Cc: pgsql-hackers
On 5/21/23 3:24 PM, Andres Freund wrote:
> Hi,
>
> On May 21, 2023 11:46:56 AM PDT, "Jonathan S. Katz" <[email protected]> wrote:
>> On 5/21/23 1:13 PM, Andres Freund wrote:
>>
>>>
>>> Looking through the release notes, I didn't see an entry for
>>>
>>> commit c6e0fe1f2a08505544c410f613839664eea9eb21
>>> Author: David Rowley <[email protected]>
>>> Date: 2022-08-29 17:15:00 +1200
>>> Improve performance of and reduce overheads of memory management
>>>
>>> even though I think that's one of the more impactful improvements. What was
>>> the reason for leaving that out?
>>
>> IIUC in[1], would this "just speed up" read-heavy workloads?
>
> I don't think so. It can speed up write workloads as well. But more importantly it can noticeably reduce memory usage, including for things like the relcache.
Cool! I'll dive more into the thread later to learn more.
Jonathan
Attachments:
[application/pgp-signature] OpenPGP_signature (840B, ../../[email protected]/2-OpenPGP_signature)
download
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v3 3/4] Add invalidation-based retry loop for Alter/Drop Subscription
@ 2026-07-03 14:03 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:03 UTC (permalink / raw)
Following the approach of RangeVarGetRelidExtended() for relations, add a
retry loop that includes name resolution, ownership check, and lock
acquisition in AlterSubscription() and DropSubscription().
The loop records SharedInvalidMessageCounter, resolves the subscription name
to an OID, checks ownership, then locks the subscription. If the invalidation
counter changed (indicating concurrent DDL), we save the current OID and
retry. On the next iteration, if the name still resolves to the same OID,
we're done (already holding the correct lock). If it resolves to a different
OID, we release the old lock and acquire the new one.
This mirrors RangeVarGetRelidExtended()'s behavior: the lock is kept across
retries to avoid a window where another session could have committed concurrent
DDL modifying the ownership and/or the name resolution.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by:
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/subscriptioncmds.c | 167 +++++++++++++++++-------
1 file changed, 118 insertions(+), 49 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c
index e23b366a87d..866341c2cfb 100644
--- a/src/backend/commands/subscriptioncmds.c
+++ b/src/backend/commands/subscriptioncmds.c
@@ -50,6 +50,7 @@
#include "replication/walsender.h"
#include "replication/worker_internal.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
@@ -1592,23 +1593,67 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
rel = table_open(SubscriptionRelationId, RowExclusiveLock);
- /* Fetch the existing tuple. */
- tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, ObjectIdGetDatum(MyDatabaseId),
- CStringGetDatum(stmt->subname));
+ /*
+ * Lock the subscription so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
+ */
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
+ tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ heap_freetuple(tup);
+ }
+ }
/* parse and check options */
switch (stmt->kind)
@@ -1686,25 +1731,6 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
orig_conninfo_needed = false;
}
- heap_freetuple(tup);
-
- /* Lock the subscription so nobody else can do anything with it. */
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
-
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * DROP or ALTER may have committed before we acquired the lock.
- */
- tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
-
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
-
- form = (Form_pg_subscription) GETSTRUCT(tup);
-
/*
* Skip ACL checks on the subscription's foreign server, if any. If
* changing the server (or replacing it with a raw connection), then the
@@ -2570,11 +2596,6 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
form = (Form_pg_subscription) GETSTRUCT(tup);
subid = form->oid;
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
-
/* DROP hook for the subscription being removed */
InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
@@ -2583,20 +2604,68 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
/*
* Lock the subscription so nobody else can do anything with it (including
* the replication workers).
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
*/
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * ALTER or DROP may have committed before we acquired the lock.
- */
- tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ tup = SearchSysCache2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
+
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ {
+ ReleaseSysCache(tup);
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+ }
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ ReleaseSysCache(tup);
+ }
+ }
form = (Form_pg_subscription) GETSTRUCT(tup);
subowner = form->subowner;
--
2.34.1
--3eAVwo4vDNlHc8RC
Content-Type: text/x-diff; charset=us-ascii
Content-Disposition: attachment;
filename="v3-0004-Add-invalidation-based-retry-loop-for-AlterPublic.patch"
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v3 3/4] Add invalidation-based retry loop for Alter/Drop Subscription
@ 2026-07-03 14:03 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:03 UTC (permalink / raw)
Following the approach of RangeVarGetRelidExtended() for relations, add a
retry loop that includes name resolution, ownership check, and lock
acquisition in AlterSubscription() and DropSubscription().
The loop records SharedInvalidMessageCounter, resolves the subscription name
to an OID, checks ownership, then locks the subscription. If the invalidation
counter changed (indicating concurrent DDL), we save the current OID and
retry. On the next iteration, if the name still resolves to the same OID,
we're done (already holding the correct lock). If it resolves to a different
OID, we release the old lock and acquire the new one.
This mirrors RangeVarGetRelidExtended()'s behavior: the lock is kept across
retries to avoid a window where another session could have committed concurrent
DDL modifying the ownership and/or the name resolution.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by:
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/subscriptioncmds.c | 167 +++++++++++++++++-------
1 file changed, 118 insertions(+), 49 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c
index e23b366a87d..866341c2cfb 100644
--- a/src/backend/commands/subscriptioncmds.c
+++ b/src/backend/commands/subscriptioncmds.c
@@ -50,6 +50,7 @@
#include "replication/walsender.h"
#include "replication/worker_internal.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
@@ -1592,23 +1593,67 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
rel = table_open(SubscriptionRelationId, RowExclusiveLock);
- /* Fetch the existing tuple. */
- tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, ObjectIdGetDatum(MyDatabaseId),
- CStringGetDatum(stmt->subname));
+ /*
+ * Lock the subscription so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
+ */
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
+ tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ heap_freetuple(tup);
+ }
+ }
/* parse and check options */
switch (stmt->kind)
@@ -1686,25 +1731,6 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
orig_conninfo_needed = false;
}
- heap_freetuple(tup);
-
- /* Lock the subscription so nobody else can do anything with it. */
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
-
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * DROP or ALTER may have committed before we acquired the lock.
- */
- tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
-
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
-
- form = (Form_pg_subscription) GETSTRUCT(tup);
-
/*
* Skip ACL checks on the subscription's foreign server, if any. If
* changing the server (or replacing it with a raw connection), then the
@@ -2570,11 +2596,6 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
form = (Form_pg_subscription) GETSTRUCT(tup);
subid = form->oid;
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
-
/* DROP hook for the subscription being removed */
InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
@@ -2583,20 +2604,68 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
/*
* Lock the subscription so nobody else can do anything with it (including
* the replication workers).
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
*/
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * ALTER or DROP may have committed before we acquired the lock.
- */
- tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ tup = SearchSysCache2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
+
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ {
+ ReleaseSysCache(tup);
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+ }
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ ReleaseSysCache(tup);
+ }
+ }
form = (Form_pg_subscription) GETSTRUCT(tup);
subowner = form->subowner;
--
2.34.1
--3eAVwo4vDNlHc8RC
Content-Type: text/x-diff; charset=us-ascii
Content-Disposition: attachment;
filename="v3-0004-Add-invalidation-based-retry-loop-for-AlterPublic.patch"
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v4 4/4] Add invalidation-based retry loop for AlterPublication
@ 2026-07-03 14:46 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:46 UTC (permalink / raw)
Apply the same RangeVarGetRelidExtended() style retry loop to
AlterPublication()'s tables/schemas branch that was added for subscriptions
in commit XXXX.
Previously, this branch resolved the publication name and checked ownership
at the top of AlterPublication(), then locked and re-read by OID. This left a
window where concurrent DDL could have modified the ownership and/or the name
resolution
Now the tables/schemas branch has its own complete retry loop: name
resolution, ownership check, and lock acquisition all inside the loop.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by: Dilip Kumar <[email protected]>
Reviewed-by: Hayato Kuroda (Fujitsu) <[email protected]>
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/publicationcmds.c | 105 +++++++++++++++++--------
1 file changed, 72 insertions(+), 33 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 440adb356ad..dfd707bc7d7 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -39,6 +39,7 @@
#include "parser/parse_relation.h"
#include "rewrite/rewriteHandler.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/inval.h"
@@ -1662,54 +1663,92 @@ AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
rel = table_open(PublicationRelationId, RowExclusiveLock);
- tup = SearchSysCacheCopy1(PUBLICATIONNAME,
- CStringGetDatum(stmt->pubname));
+ if (stmt->options)
+ {
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname)));
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
- /* must be owner */
- if (!object_ownercheck(PublicationRelationId, pubform->oid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
- stmt->pubname);
+ /* must be owner */
+ if (!object_ownercheck(PublicationRelationId, pubform->oid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
- if (stmt->options)
AlterPublicationOptions(pstate, stmt, rel, tup);
+ }
else
{
List *relations = NIL;
List *exceptrelations = NIL;
List *schemaidlist = NIL;
- Oid pubid = pubform->oid;
+ Oid pubid;
- ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
- &exceptrelations, &schemaidlist);
+ /*
+ * Lock the publication so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation
+ * messages arrive (indicating concurrent DDL), we retry. We keep the
+ * lock held across retries and only release it if the name resolves
+ * to a different OID on the next iteration.
+ */
+ {
+ Oid oldPubId = InvalidOid;
+ bool retry = false;
- CheckAlterPublication(stmt, tup, relations, schemaidlist);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- heap_freetuple(tup);
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- /* Lock the publication so nobody else can do anything with it. */
- LockDatabaseObject(PublicationRelationId, pubid, 0,
- AccessExclusiveLock);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- /*
- * It is possible that by the time we acquire the lock on publication,
- * concurrent DDL has removed it. We can test this by checking the
- * existence of publication. We get the tuple again to avoid the risk
- * of any publication option getting changed.
- */
- tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname));
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubid = pubform->oid;
+
+ if (!object_ownercheck(PublicationRelationId, pubid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
+
+ if (retry)
+ {
+ if (pubid == oldPubId)
+ break;
+ UnlockDatabaseObject(PublicationRelationId, oldPubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockDatabaseObject(PublicationRelationId, pubid, 0,
+ AccessExclusiveLock);
+
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ retry = true;
+ oldPubId = pubid;
+ heap_freetuple(tup);
+ }
+ }
+
+ ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
+ &exceptrelations, &schemaidlist);
+
+ CheckAlterPublication(stmt, tup, relations, schemaidlist);
relations = list_concat(relations, exceptrelations);
AlterPublicationTables(stmt, tup, relations, pstate->p_sourcetext,
--
2.34.1
--b+bwjVhifbzgesmw--
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v3 4/4] Add invalidation-based retry loop for AlterPublication
@ 2026-07-03 14:46 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:46 UTC (permalink / raw)
Apply the same RangeVarGetRelidExtended() style retry loop to
AlterPublication()'s tables/schemas branch that was added for subscriptions
in commit XXXX.
Previously, this branch resolved the publication name and checked ownership
at the top of AlterPublication(), then locked and re-read by OID. This left a
window where concurrent DDL could have modified the ownership and/or the name
resolution
Now the tables/schemas branch has its own complete retry loop: name
resolution, ownership check, and lock acquisition all inside the loop.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by:
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/publicationcmds.c | 105 +++++++++++++++++--------
1 file changed, 72 insertions(+), 33 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 440adb356ad..dfd707bc7d7 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -39,6 +39,7 @@
#include "parser/parse_relation.h"
#include "rewrite/rewriteHandler.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/inval.h"
@@ -1662,54 +1663,92 @@ AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
rel = table_open(PublicationRelationId, RowExclusiveLock);
- tup = SearchSysCacheCopy1(PUBLICATIONNAME,
- CStringGetDatum(stmt->pubname));
+ if (stmt->options)
+ {
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname)));
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
- /* must be owner */
- if (!object_ownercheck(PublicationRelationId, pubform->oid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
- stmt->pubname);
+ /* must be owner */
+ if (!object_ownercheck(PublicationRelationId, pubform->oid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
- if (stmt->options)
AlterPublicationOptions(pstate, stmt, rel, tup);
+ }
else
{
List *relations = NIL;
List *exceptrelations = NIL;
List *schemaidlist = NIL;
- Oid pubid = pubform->oid;
+ Oid pubid;
- ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
- &exceptrelations, &schemaidlist);
+ /*
+ * Lock the publication so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation
+ * messages arrive (indicating concurrent DDL), we retry. We keep the
+ * lock held across retries and only release it if the name resolves
+ * to a different OID on the next iteration.
+ */
+ {
+ Oid oldPubId = InvalidOid;
+ bool retry = false;
- CheckAlterPublication(stmt, tup, relations, schemaidlist);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- heap_freetuple(tup);
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- /* Lock the publication so nobody else can do anything with it. */
- LockDatabaseObject(PublicationRelationId, pubid, 0,
- AccessExclusiveLock);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- /*
- * It is possible that by the time we acquire the lock on publication,
- * concurrent DDL has removed it. We can test this by checking the
- * existence of publication. We get the tuple again to avoid the risk
- * of any publication option getting changed.
- */
- tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname));
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubid = pubform->oid;
+
+ if (!object_ownercheck(PublicationRelationId, pubid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
+
+ if (retry)
+ {
+ if (pubid == oldPubId)
+ break;
+ UnlockDatabaseObject(PublicationRelationId, oldPubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockDatabaseObject(PublicationRelationId, pubid, 0,
+ AccessExclusiveLock);
+
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ retry = true;
+ oldPubId = pubid;
+ heap_freetuple(tup);
+ }
+ }
+
+ ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
+ &exceptrelations, &schemaidlist);
+
+ CheckAlterPublication(stmt, tup, relations, schemaidlist);
relations = list_concat(relations, exceptrelations);
AlterPublicationTables(stmt, tup, relations, pstate->p_sourcetext,
--
2.34.1
--3eAVwo4vDNlHc8RC--
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v4 4/4] Add invalidation-based retry loop for AlterPublication
@ 2026-07-03 14:46 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:46 UTC (permalink / raw)
Apply the same RangeVarGetRelidExtended() style retry loop to
AlterPublication()'s tables/schemas branch that was added for subscriptions
in commit XXXX.
Previously, this branch resolved the publication name and checked ownership
at the top of AlterPublication(), then locked and re-read by OID. This left a
window where concurrent DDL could have modified the ownership and/or the name
resolution
Now the tables/schemas branch has its own complete retry loop: name
resolution, ownership check, and lock acquisition all inside the loop.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by: Dilip Kumar <[email protected]>
Reviewed-by: Hayato Kuroda (Fujitsu) <[email protected]>
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/publicationcmds.c | 105 +++++++++++++++++--------
1 file changed, 72 insertions(+), 33 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 440adb356ad..dfd707bc7d7 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -39,6 +39,7 @@
#include "parser/parse_relation.h"
#include "rewrite/rewriteHandler.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/inval.h"
@@ -1662,54 +1663,92 @@ AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
rel = table_open(PublicationRelationId, RowExclusiveLock);
- tup = SearchSysCacheCopy1(PUBLICATIONNAME,
- CStringGetDatum(stmt->pubname));
+ if (stmt->options)
+ {
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname)));
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
- /* must be owner */
- if (!object_ownercheck(PublicationRelationId, pubform->oid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
- stmt->pubname);
+ /* must be owner */
+ if (!object_ownercheck(PublicationRelationId, pubform->oid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
- if (stmt->options)
AlterPublicationOptions(pstate, stmt, rel, tup);
+ }
else
{
List *relations = NIL;
List *exceptrelations = NIL;
List *schemaidlist = NIL;
- Oid pubid = pubform->oid;
+ Oid pubid;
- ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
- &exceptrelations, &schemaidlist);
+ /*
+ * Lock the publication so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation
+ * messages arrive (indicating concurrent DDL), we retry. We keep the
+ * lock held across retries and only release it if the name resolves
+ * to a different OID on the next iteration.
+ */
+ {
+ Oid oldPubId = InvalidOid;
+ bool retry = false;
- CheckAlterPublication(stmt, tup, relations, schemaidlist);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- heap_freetuple(tup);
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- /* Lock the publication so nobody else can do anything with it. */
- LockDatabaseObject(PublicationRelationId, pubid, 0,
- AccessExclusiveLock);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- /*
- * It is possible that by the time we acquire the lock on publication,
- * concurrent DDL has removed it. We can test this by checking the
- * existence of publication. We get the tuple again to avoid the risk
- * of any publication option getting changed.
- */
- tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname));
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubid = pubform->oid;
+
+ if (!object_ownercheck(PublicationRelationId, pubid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
+
+ if (retry)
+ {
+ if (pubid == oldPubId)
+ break;
+ UnlockDatabaseObject(PublicationRelationId, oldPubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockDatabaseObject(PublicationRelationId, pubid, 0,
+ AccessExclusiveLock);
+
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ retry = true;
+ oldPubId = pubid;
+ heap_freetuple(tup);
+ }
+ }
+
+ ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
+ &exceptrelations, &schemaidlist);
+
+ CheckAlterPublication(stmt, tup, relations, schemaidlist);
relations = list_concat(relations, exceptrelations);
AlterPublicationTables(stmt, tup, relations, pstate->p_sourcetext,
--
2.34.1
--b+bwjVhifbzgesmw--
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v3 4/4] Add invalidation-based retry loop for AlterPublication
@ 2026-07-03 14:46 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-03 14:46 UTC (permalink / raw)
Apply the same RangeVarGetRelidExtended() style retry loop to
AlterPublication()'s tables/schemas branch that was added for subscriptions
in commit XXXX.
Previously, this branch resolved the publication name and checked ownership
at the top of AlterPublication(), then locked and re-read by OID. This left a
window where concurrent DDL could have modified the ownership and/or the name
resolution
Now the tables/schemas branch has its own complete retry loop: name
resolution, ownership check, and lock acquisition all inside the loop.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by:
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/publicationcmds.c | 105 +++++++++++++++++--------
1 file changed, 72 insertions(+), 33 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 440adb356ad..dfd707bc7d7 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -39,6 +39,7 @@
#include "parser/parse_relation.h"
#include "rewrite/rewriteHandler.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/inval.h"
@@ -1662,54 +1663,92 @@ AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
rel = table_open(PublicationRelationId, RowExclusiveLock);
- tup = SearchSysCacheCopy1(PUBLICATIONNAME,
- CStringGetDatum(stmt->pubname));
+ if (stmt->options)
+ {
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname)));
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
- /* must be owner */
- if (!object_ownercheck(PublicationRelationId, pubform->oid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
- stmt->pubname);
+ /* must be owner */
+ if (!object_ownercheck(PublicationRelationId, pubform->oid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
- if (stmt->options)
AlterPublicationOptions(pstate, stmt, rel, tup);
+ }
else
{
List *relations = NIL;
List *exceptrelations = NIL;
List *schemaidlist = NIL;
- Oid pubid = pubform->oid;
+ Oid pubid;
- ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
- &exceptrelations, &schemaidlist);
+ /*
+ * Lock the publication so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation
+ * messages arrive (indicating concurrent DDL), we retry. We keep the
+ * lock held across retries and only release it if the name resolves
+ * to a different OID on the next iteration.
+ */
+ {
+ Oid oldPubId = InvalidOid;
+ bool retry = false;
- CheckAlterPublication(stmt, tup, relations, schemaidlist);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- heap_freetuple(tup);
+ tup = SearchSysCacheCopy1(PUBLICATIONNAME,
+ CStringGetDatum(stmt->pubname));
- /* Lock the publication so nobody else can do anything with it. */
- LockDatabaseObject(PublicationRelationId, pubid, 0,
- AccessExclusiveLock);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("publication \"%s\" does not exist",
+ stmt->pubname)));
- /*
- * It is possible that by the time we acquire the lock on publication,
- * concurrent DDL has removed it. We can test this by checking the
- * existence of publication. We get the tuple again to avoid the risk
- * of any publication option getting changed.
- */
- tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("publication \"%s\" does not exist",
- stmt->pubname));
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+ pubid = pubform->oid;
+
+ if (!object_ownercheck(PublicationRelationId, pubid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
+ stmt->pubname);
+
+ if (retry)
+ {
+ if (pubid == oldPubId)
+ break;
+ UnlockDatabaseObject(PublicationRelationId, oldPubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockDatabaseObject(PublicationRelationId, pubid, 0,
+ AccessExclusiveLock);
+
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ retry = true;
+ oldPubId = pubid;
+ heap_freetuple(tup);
+ }
+ }
+
+ ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
+ &exceptrelations, &schemaidlist);
+
+ CheckAlterPublication(stmt, tup, relations, schemaidlist);
relations = list_concat(relations, exceptrelations);
AlterPublicationTables(stmt, tup, relations, pstate->p_sourcetext,
--
2.34.1
--3eAVwo4vDNlHc8RC--
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v4 3/4] Add invalidation-based retry loop for Alter/Drop Subscription
@ 2026-07-06 04:44 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-06 04:44 UTC (permalink / raw)
Following the approach of RangeVarGetRelidExtended() for relations, add a
retry loop that includes name resolution, ownership check, and lock
acquisition in AlterSubscription() and DropSubscription().
The loop records SharedInvalidMessageCounter, resolves the subscription name
to an OID, checks ownership, then locks the subscription. If the invalidation
counter changed (indicating concurrent DDL), we save the current OID and
retry. On the next iteration, if the name still resolves to the same OID,
we're done (already holding the correct lock). If it resolves to a different
OID, we release the old lock and acquire the new one.
This mirrors RangeVarGetRelidExtended()'s behavior: the lock is kept across
retries to avoid a window where another session could have committed concurrent
DDL modifying the ownership and/or the name resolution.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by: Dilip Kumar <[email protected]>
Reviewed-by: Hayato Kuroda (Fujitsu) <[email protected]>
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/subscriptioncmds.c | 189 +++++++++++++++++-------
1 file changed, 134 insertions(+), 55 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c
index c9e7fbdb47b..615c3921bc3 100644
--- a/src/backend/commands/subscriptioncmds.c
+++ b/src/backend/commands/subscriptioncmds.c
@@ -50,6 +50,7 @@
#include "replication/walsender.h"
#include "replication/worker_internal.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
@@ -1592,23 +1593,67 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
rel = table_open(SubscriptionRelationId, RowExclusiveLock);
- /* Fetch the existing tuple. */
- tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, ObjectIdGetDatum(MyDatabaseId),
- CStringGetDatum(stmt->subname));
+ /*
+ * Lock the subscription so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
+ */
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
+ tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ heap_freetuple(tup);
+ }
+ }
/* parse and check options */
switch (stmt->kind)
@@ -1686,25 +1731,6 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
orig_conninfo_needed = false;
}
- heap_freetuple(tup);
-
- /* Lock the subscription so nobody else can do anything with it. */
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
-
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * DROP or ALTER may have committed before we acquired the lock.
- */
- tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
-
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
-
- form = (Form_pg_subscription) GETSTRUCT(tup);
-
/*
* Skip ACL checks on the subscription's foreign server, if any. If
* changing the server (or replacing it with a raw connection), then the
@@ -2567,38 +2593,91 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
return;
}
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
-
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
-
ReleaseSysCache(tup);
/*
* Lock the subscription so nobody else can do anything with it (including
* the replication workers).
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
*/
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- /* DROP hook for the subscription being removed */
- InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * ALTER or DROP may have committed before we acquired the lock.
- */
- tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
+ tup = SearchSysCache2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ if (!HeapTupleIsValid(tup))
+ {
+ if (retry)
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ table_close(rel, NoLock);
+
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+ else
+ ereport(NOTICE,
+ (errmsg("subscription \"%s\" does not exist, skipping",
+ stmt->subname)));
+
+ return;
+ }
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ {
+ ReleaseSysCache(tup);
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+ }
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ ReleaseSysCache(tup);
+ }
+ }
+
+ /* DROP hook for the subscription being removed */
+ InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
- form = (Form_pg_subscription) GETSTRUCT(tup);
subowner = form->subowner;
subserver = form->subserver;
subconflictlogrelid = form->subconflictlogrelid;
--
2.34.1
--b+bwjVhifbzgesmw
Content-Type: text/x-diff; charset=us-ascii
Content-Disposition: attachment;
filename="v4-0004-Add-invalidation-based-retry-loop-for-AlterPublic.patch"
^ permalink raw reply [nested|flat] 9+ messages in thread
* [PATCH v4 3/4] Add invalidation-based retry loop for Alter/Drop Subscription
@ 2026-07-06 04:44 Bertrand Drouvot <[email protected]>
0 siblings, 0 replies; 9+ messages in thread
From: Bertrand Drouvot @ 2026-07-06 04:44 UTC (permalink / raw)
Following the approach of RangeVarGetRelidExtended() for relations, add a
retry loop that includes name resolution, ownership check, and lock
acquisition in AlterSubscription() and DropSubscription().
The loop records SharedInvalidMessageCounter, resolves the subscription name
to an OID, checks ownership, then locks the subscription. If the invalidation
counter changed (indicating concurrent DDL), we save the current OID and
retry. On the next iteration, if the name still resolves to the same OID,
we're done (already holding the correct lock). If it resolves to a different
OID, we release the old lock and acquire the new one.
This mirrors RangeVarGetRelidExtended()'s behavior: the lock is kept across
retries to avoid a window where another session could have committed concurrent
DDL modifying the ownership and/or the name resolution.
Author: Bertrand Drouvot <[email protected]>
Reviewed-by: Dilip Kumar <[email protected]>
Reviewed-by: Hayato Kuroda (Fujitsu) <[email protected]>
Discussion: https://postgr.es/m/akZUpiDa1UfmzYxL%40bdtpg
---
src/backend/commands/subscriptioncmds.c | 189 +++++++++++++++++-------
1 file changed, 134 insertions(+), 55 deletions(-)
100.0% src/backend/commands/
diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c
index c9e7fbdb47b..615c3921bc3 100644
--- a/src/backend/commands/subscriptioncmds.c
+++ b/src/backend/commands/subscriptioncmds.c
@@ -50,6 +50,7 @@
#include "replication/walsender.h"
#include "replication/worker_internal.h"
#include "storage/lmgr.h"
+#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
@@ -1592,23 +1593,67 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
rel = table_open(SubscriptionRelationId, RowExclusiveLock);
- /* Fetch the existing tuple. */
- tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, ObjectIdGetDatum(MyDatabaseId),
- CStringGetDatum(stmt->subname));
+ /*
+ * Lock the subscription so nobody else can do anything with it.
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
+ */
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
+ tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ heap_freetuple(tup);
+ }
+ }
/* parse and check options */
switch (stmt->kind)
@@ -1686,25 +1731,6 @@ AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt,
orig_conninfo_needed = false;
}
- heap_freetuple(tup);
-
- /* Lock the subscription so nobody else can do anything with it. */
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
-
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * DROP or ALTER may have committed before we acquired the lock.
- */
- tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
-
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
-
- form = (Form_pg_subscription) GETSTRUCT(tup);
-
/*
* Skip ACL checks on the subscription's foreign server, if any. If
* changing the server (or replacing it with a raw connection), then the
@@ -2567,38 +2593,91 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
return;
}
- form = (Form_pg_subscription) GETSTRUCT(tup);
- subid = form->oid;
-
- /* must be owner */
- if (!object_ownercheck(SubscriptionRelationId, subid, GetUserId()))
- aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
- stmt->subname);
-
ReleaseSysCache(tup);
/*
* Lock the subscription so nobody else can do anything with it (including
* the replication workers).
+ *
+ * Like RangeVarGetRelidExtended() does for relations, we resolve the
+ * name, check ownership, and lock inside a loop. If invalidation messages
+ * arrive (indicating concurrent DDL), we retry. We keep the lock held
+ * across retries and only release it if the name resolves to a different
+ * OID on the next iteration.
*/
- LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);
+ {
+ Oid oldSubId = InvalidOid;
+ bool retry = false;
- /* DROP hook for the subscription being removed */
- InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
+ for (;;)
+ {
+ uint64 inval_count = SharedInvalidMessageCounter;
- /*
- * Re-read the subscription tuple after acquiring the lock. A concurrent
- * ALTER or DROP may have committed before we acquired the lock.
- */
- tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
+ tup = SearchSysCache2(SUBSCRIPTIONNAME,
+ ObjectIdGetDatum(MyDatabaseId),
+ CStringGetDatum(stmt->subname));
- if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("subscription \"%s\" does not exist",
- stmt->subname)));
+ if (!HeapTupleIsValid(tup))
+ {
+ if (retry)
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ table_close(rel, NoLock);
+
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("subscription \"%s\" does not exist",
+ stmt->subname)));
+ else
+ ereport(NOTICE,
+ (errmsg("subscription \"%s\" does not exist, skipping",
+ stmt->subname)));
+
+ return;
+ }
+
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
+ if (!object_ownercheck(SubscriptionRelationId, subid,
+ GetUserId()))
+ {
+ ReleaseSysCache(tup);
+ aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
+ stmt->subname);
+ }
+
+ /*
+ * If upon retry we get the same OID, the invalidation messages
+ * did not change the final answer. So we're done. If we got a
+ * different OID, unlock the old one and lock the new one below.
+ */
+ if (retry)
+ {
+ if (subid == oldSubId)
+ break;
+ UnlockSharedObject(SubscriptionRelationId, oldSubId, 0,
+ AccessExclusiveLock);
+ }
+
+ LockSharedObject(SubscriptionRelationId, subid, 0,
+ AccessExclusiveLock);
+
+ /* If no invalidation messages, we're done. */
+ if (inval_count == SharedInvalidMessageCounter)
+ break;
+
+ /* Something may have changed, retry. */
+ retry = true;
+ oldSubId = subid;
+ ReleaseSysCache(tup);
+ }
+ }
+
+ /* DROP hook for the subscription being removed */
+ InvokeObjectDropHook(SubscriptionRelationId, subid, 0);
- form = (Form_pg_subscription) GETSTRUCT(tup);
subowner = form->subowner;
subserver = form->subserver;
subconflictlogrelid = form->subconflictlogrelid;
--
2.34.1
--b+bwjVhifbzgesmw
Content-Type: text/x-diff; charset=us-ascii
Content-Disposition: attachment;
filename="v4-0004-Add-invalidation-based-retry-loop-for-AlterPublic.patch"
^ permalink raw reply [nested|flat] 9+ messages in thread
end of thread, other threads:[~2026-07-06 04:44 UTC | newest]
Thread overview: 9+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2023-05-21 23:51 Re: PG 16 draft release notes ready Jonathan S. Katz <[email protected]>
2026-07-03 14:03 [PATCH v3 3/4] Add invalidation-based retry loop for Alter/Drop Subscription Bertrand Drouvot <[email protected]>
2026-07-03 14:03 [PATCH v3 3/4] Add invalidation-based retry loop for Alter/Drop Subscription Bertrand Drouvot <[email protected]>
2026-07-03 14:46 [PATCH v4 4/4] Add invalidation-based retry loop for AlterPublication Bertrand Drouvot <[email protected]>
2026-07-03 14:46 [PATCH v3 4/4] Add invalidation-based retry loop for AlterPublication Bertrand Drouvot <[email protected]>
2026-07-03 14:46 [PATCH v4 4/4] Add invalidation-based retry loop for AlterPublication Bertrand Drouvot <[email protected]>
2026-07-03 14:46 [PATCH v3 4/4] Add invalidation-based retry loop for AlterPublication Bertrand Drouvot <[email protected]>
2026-07-06 04:44 [PATCH v4 3/4] Add invalidation-based retry loop for Alter/Drop Subscription Bertrand Drouvot <[email protected]>
2026-07-06 04:44 [PATCH v4 3/4] Add invalidation-based retry loop for Alter/Drop Subscription Bertrand Drouvot <[email protected]>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox