Issue with logical replication slot during switchover

From 58403718a39b81aa107e29bd1791e158f19e5646 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice.chapuis@zas.admin.ch>
Date: Mon, 28 Jul 2025 15:27:03 +0200
Subject: [PATCH v1] fix failover slot issue when doing a switchover

---
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/replication/logical/slotsync.c | 44 +++++++++++++++++-----
 src/backend/replication/slot.c             |  7 +++-
 src/backend/replication/slotfuncs.c        | 10 +++--
 src/backend/replication/walsender.c        |  4 +-
 src/include/catalog/pg_proc.dat            |  8 ++--
 src/include/replication/slot.h             |  7 +++-
 7 files changed, 59 insertions(+), 22 deletions(-)

diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 566f308..6cd3175 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 656e66e..d6332cd 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -627,6 +627,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	ReplicationSlot *slot;
 	XLogRecPtr	latestFlushPtr;
 	bool		slot_updated = false;
+	bool 		allow_overwrite = false;		
 
 	/*
 	 * Make sure that concerned WAL is received and flushed before syncing
@@ -649,24 +650,46 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 
 		return false;
 	}
-
-	/* Search for the named slot */
+	// Both local and remote slot have the same name
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
-		bool		synced;
+		bool		synced;	
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
-
-		/* User-created slot with the same name exists, raise ERROR. */
-		if (!synced)
-			ereport(ERROR,
+	
+		if (!synced){						
+			/* 
+			 * Check if we need to overwrite an existing
+			 * logical slot 
+			*/
+			if (allow_overwrite){								
+				/* 
+				 * Get rid of a replication slot that is no
+				 *longer wanted 
+				*/
+				ReplicationSlotDrop(remote_slot->name,true);
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ereport(WARNING,
+					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+					errmsg("slot \"%s\" already exists"
+                            " on the standby but it will be dropped because flag allow_overwrite is set to true",
+                             remote_slot->name));
+				
+				/* Going back to the main loop after droping the failover slot */
+				return false; 			
+			}
+			else
+				/* User-created slot with the same name exists, raise ERROR. */  
+				ereport(ERROR,
 					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
-
+							" name slot \"%s\" already exists on the standby",
+							remote_slot->name));			
+		}		
 		/*
 		 * The slot has been synchronized before.
 		 *
@@ -761,6 +784,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  allow_overwrite,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index 600b87f..d6bc5c6 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -323,7 +323,7 @@ ReplicationSlotValidateName(const char *name, int elevel)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -413,6 +413,11 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
 	slot->data.synced = synced;
+	slot->data.allow_overwrite = allow_overwrite;
+
+	elog(LOG, "Logical replication slot %s created with option allow_overwrite to %s",
+     NameStr(slot->data.name),
+     slot->data.allow_overwrite ? "true" : "false");
 
 	/* and then data only present in shared memory */
 	slot->just_dirtied = false;
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index 36cc2ed..5dd5f50 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -40,7 +40,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
-						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
+						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false, false,
 						  false, false);
 
 	if (immediately_reserve)
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5); 
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -210,7 +212,6 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	PG_RETURN_DATUM(result);
 }
 
-
 /*
  * SQL function for dropping a replication slot.
  */
@@ -726,6 +727,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 9fa8beb..ef22695 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1198,7 +1198,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1229,7 +1229,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 62beb71..074805d 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11480,10 +11480,10 @@
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index eb0b93b..1fd6445 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -134,6 +134,11 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure 
+	 * creation of new failover slot when sync_replication_slots is true.
+	 */
+	bool		allow_overwrite;	
 } ReplicationSlotPersistentData;
 
 /*
@@ -267,7 +272,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From e12031e0bdf098811d2fc99962a04c01a0ee77f9 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice.chapuis@zas.admin.ch>
Date: Sun, 7 Sep 2025 09:37:24 +0200
Subject: [PATCH v1] Fix-failover-slot-issue-when-doing-a-switchover.

Add allow_overwrite parameter to pg_create_logical_replication_slot.
If allow_overwrite is set to true then existing failover slot on standby
will be dropped, then ensure main loop continues after drop and create a
new slot.
---
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/replication/logical/launcher.c |  2 +-
 src/backend/replication/logical/slotsync.c | 25 +++++++++++++++++++++-
 src/backend/replication/slot.c             |  6 +++++-
 src/backend/replication/slotfuncs.c        |  9 +++++---
 src/backend/replication/walsender.c        |  4 ++--
 src/include/catalog/pg_proc.dat            |  8 +++----
 src/include/replication/slot.h             |  8 ++++++-
 8 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 566f308..6cd3175 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 37377f7..840741e 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1455,7 +1455,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false,false);
 
 	LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index caa003c..2a8692e 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -626,6 +626,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	ReplicationSlot *slot;
 	XLogRecPtr	latestFlushPtr;
 	bool		slot_updated = false;
+	bool		allow_overwrite = false;
 
 	/*
 	 * Make sure that concerned WAL is received and flushed before syncing
@@ -656,15 +657,36 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotDrop(remote_slot->name,true);
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ereport(WARNING,
+					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+					errmsg("slot \"%s\" already exists"
+						" on the standby but it will be dropped because "
+						"flag allow_overwrite is set to true",
+						remote_slot->name));
+
+				/* Going back to the main loop after droping the failover slot */
+				return false;
+			}
+			else
+				ereport(ERROR,
 					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 					errmsg("exiting from slot synchronization because same"
 						   " name slot \"%s\" already exists on the standby",
 						   remote_slot->name));
+		}
 
 		/*
 		 * The slot has been synchronized before.
@@ -760,6 +782,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  allow_overwrite,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb9..9a85fb0 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
@@ -500,6 +501,9 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	 */
 	LWLockRelease(ReplicationSlotAllocationLock);
 
+	elog(DEBUG1, "logical replication slot %s created with option allow_overwrite to %s",
+		 NameStr(slot->data.name), slot->data.allow_overwrite ? "true" : "false");
+
 	/* Let everybody know we've modified this slot */
 	ConditionVariableBroadcast(&slot->active_cv);
 }
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index 69f4c61..3f53502 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false,false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -726,6 +728,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index e3dce9d..a2db1e3 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1201,7 +1201,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1232,7 +1232,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 118d6da..ee55572 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11498,10 +11498,10 @@
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index e8fc342..eef5c86 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From 5b13c0061fd354c9e77991ab401a1788464e7b64 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Fri, 26 Sep 2025 17:52:39 +0200
Subject: [PATCH v1] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.

Signed-off-by: Fabrice Chapuis <fabrice636861@gmail.com>
---
 src/backend/catalog/system_functions.sql   |   1 +
 src/backend/replication/logical/launcher.c |   2 +-
 src/backend/replication/logical/slotsync.c | 205 ++++++++++++++-------
 src/backend/replication/slot.c             |   3 +-
 src/backend/replication/slotfuncs.c        |   9 +-
 src/backend/replication/walsender.c        |   4 +-
 src/include/catalog/pg_proc.dat            |   8 +-
 src/include/replication/slot.h             |   8 +-
 8 files changed, 160 insertions(+), 80 deletions(-)

diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 566f308..6cd3175 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 37377f7..b7bef13 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1455,7 +1455,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index caa003c..6933e8d 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -653,92 +653,160 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				/* Recreate the failover slot and synchronize it */
+				NameData	plugin_name;
+				TransactionId xmin_horizon = InvalidTransactionId;
+
+				ereport(WARNING,
+					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+					errmsg("slot \"%s\" already exists"
+					" on the standby but try to recreate it because "
+					"flag allow_overwrite is set to true",
+						remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotDrop(remote_slot->name,true);
+
+				/* Skip creating the local slot if remote_slot is invalidated already */
+				if (remote_slot->invalidated != RS_INVAL_NONE)
+					return false;
+
+				/*
+				* We create temporary slots instead of ephemeral slots here because
+				* we want the slots to survive after releasing them. This is done to
+				* avoid dropping and re-creating the slots in each synchronization
+				* cycle if the restart_lsn or catalog_xmin of the remote slot has not
+				* caught up.
+				*/
+				ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
+									remote_slot->two_phase,
+									remote_slot->failover,
+									true,
+									true);
+
+				/* For shorter lines. */
+				slot = MyReplicationSlot;
+
+				/* Avoid expensive operations while holding a spinlock. */
+				namestrcpy(&plugin_name, remote_slot->plugin);
+
+				SpinLockAcquire(&slot->mutex);
+				slot->data.database = remote_dbid;
+				slot->data.plugin = plugin_name;
+				SpinLockRelease(&slot->mutex);
+
+				reserve_wal_for_local_slot(remote_slot->restart_lsn);
+
+				LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+				xmin_horizon = GetOldestSafeDecodingTransactionId(true);
+				SpinLockAcquire(&slot->mutex);
+				slot->effective_catalog_xmin = xmin_horizon;
+				slot->data.catalog_xmin = xmin_horizon;
+				SpinLockRelease(&slot->mutex);
+				ReplicationSlotsComputeRequiredXmin(true);
+				LWLockRelease(ProcArrayLock);
+
+				update_and_persist_local_synced_slot(remote_slot, remote_dbid);
+
+				slot_updated = true;						
+			}
+			else
+				ereport(ERROR,
 					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 					errmsg("exiting from slot synchronization because same"
 						   " name slot \"%s\" already exists on the standby",
 						   remote_slot->name));
-
-		/*
-		 * The slot has been synchronized before.
-		 *
-		 * It is important to acquire the slot here before checking
-		 * invalidation. If we don't acquire the slot first, there could be a
-		 * race condition that the local slot could be invalidated just after
-		 * checking the 'invalidated' flag here and we could end up
-		 * overwriting 'invalidated' flag to remote_slot's value. See
-		 * InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
-		 * if the slot is not acquired by other processes.
-		 *
-		 * XXX: If it ever turns out that slot acquire/release is costly for
-		 * cases when none of the slot properties is changed then we can do a
-		 * pre-check to ensure that at least one of the slot properties is
-		 * changed before acquiring the slot.
-		 */
-		ReplicationSlotAcquire(remote_slot->name, true, false);
-
-		Assert(slot == MyReplicationSlot);
-
-		/*
-		 * Copy the invalidation cause from remote only if local slot is not
-		 * invalidated locally, we don't want to overwrite existing one.
-		 */
-		if (slot->data.invalidated == RS_INVAL_NONE &&
-			remote_slot->invalidated != RS_INVAL_NONE)
+		}
+		else
 		{
-			SpinLockAcquire(&slot->mutex);
-			slot->data.invalidated = remote_slot->invalidated;
-			SpinLockRelease(&slot->mutex);
+	
+			/*
+			* The slot has been synchronized before.
+			*
+			* It is important to acquire the slot here before checking
+			* invalidation. If we don't acquire the slot first, there could be a
+			* race condition that the local slot could be invalidated just after
+			* checking the 'invalidated' flag here and we could end up
+			* overwriting 'invalidated' flag to remote_slot's value. See
+			* InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
+			* if the slot is not acquired by other processes.
+			*
+			* XXX: If it ever turns out that slot acquire/release is costly for
+			* cases when none of the slot properties is changed then we can do a
+			* pre-check to ensure that at least one of the slot properties is
+			* changed before acquiring the slot.
+			*/
+			ReplicationSlotAcquire(remote_slot->name, true, false);
+
+			Assert(slot == MyReplicationSlot);
 
-			/* Make sure the invalidated state persists across server restart */
-			ReplicationSlotMarkDirty();
-			ReplicationSlotSave();
+			/*
+			* Copy the invalidation cause from remote only if local slot is not
+			* invalidated locally, we don't want to overwrite existing one.
+			*/
+			if (slot->data.invalidated == RS_INVAL_NONE &&
+				remote_slot->invalidated != RS_INVAL_NONE)
+			{
+				SpinLockAcquire(&slot->mutex);
+				slot->data.invalidated = remote_slot->invalidated;
+				SpinLockRelease(&slot->mutex);
 
-			slot_updated = true;
-		}
+				/* Make sure the invalidated state persists across server restart */
+				ReplicationSlotMarkDirty();
+				ReplicationSlotSave();
 
-		/* Skip the sync of an invalidated slot */
-		if (slot->data.invalidated != RS_INVAL_NONE)
-		{
-			ReplicationSlotRelease();
-			return slot_updated;
-		}
+				slot_updated = true;
+			}
 
-		/* Slot not ready yet, let's attempt to make it sync-ready now. */
-		if (slot->data.persistency == RS_TEMPORARY)
-		{
-			slot_updated = update_and_persist_local_synced_slot(remote_slot,
-																remote_dbid);
-		}
+			/* Skip the sync of an invalidated slot */
+			if (slot->data.invalidated != RS_INVAL_NONE)
+			{
+				ReplicationSlotRelease();
+				return slot_updated;
+			}
 
-		/* Slot ready for sync, so sync it. */
-		else
-		{
-			/*
-			 * Sanity check: As long as the invalidations are handled
-			 * appropriately as above, this should never happen.
-			 *
-			 * We don't need to check restart_lsn here. See the comments in
-			 * update_local_synced_slot() for details.
-			 */
-			if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
-				ereport(ERROR,
-						errmsg_internal("cannot synchronize local slot \"%s\"",
-										remote_slot->name),
-						errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
-										   LSN_FORMAT_ARGS(slot->data.confirmed_flush),
-										   LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
+			/* Slot not ready yet, let's attempt to make it sync-ready now. */
+			if (slot->data.persistency == RS_TEMPORARY)
+			{
+				slot_updated = update_and_persist_local_synced_slot(remote_slot,
+																	remote_dbid);
+			}
 
-			slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
-													NULL, NULL);
-		}
+			/* Slot ready for sync, so sync it. */
+			else
+			{
+				/*
+				* Sanity check: As long as the invalidations are handled
+				* appropriately as above, this should never happen.
+				*
+				* We don't need to check restart_lsn here. See the comments in
+				* update_local_synced_slot() for details.
+				*/
+				if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
+					ereport(ERROR,
+							errmsg_internal("cannot synchronize local slot \"%s\"",
+											remote_slot->name),
+							errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
+											LSN_FORMAT_ARGS(slot->data.confirmed_flush),
+											LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
+
+				slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
+														NULL, NULL);
+			}									   
+		}		
 	}
 	/* Otherwise create the slot first. */
 	else
@@ -760,6 +828,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  true,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb9..fcba4d4 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index 69f4c61..38f7460 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -726,6 +728,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index e3dce9d..a2db1e3 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1201,7 +1201,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1232,7 +1232,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 118d6da..ee55572 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11498,10 +11498,10 @@
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index e8fc342..c2e2871 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure 
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */	
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From 2ce1d7fa50df7ed6f7370b5e725a15ad11ec3d08 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Mon, 29 Sep 2025 13:10:38 +0200
Subject: [PATCH v2] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.

Signed-off-by: Fabrice Chapuis <fabrice636861@gmail.com>
---
 src/backend/catalog/system_functions.sql   |   1 +
 src/backend/replication/logical/launcher.c |   2 +-
 src/backend/replication/logical/slotsync.c | 203 ++++++++++++++-------
 src/backend/replication/slot.c             |   3 +-
 src/backend/replication/slotfuncs.c        |   9 +-
 src/backend/replication/walsender.c        |   4 +-
 src/include/catalog/pg_proc.dat            |   8 +-
 src/include/replication/slot.h             |   8 +-
 8 files changed, 159 insertions(+), 79 deletions(-)

diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 2d946d6..75ea84f 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 218cefe..a26af52 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1519,7 +1519,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	init_conflict_slot_xmin();
 }
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d5..dbf9380 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -653,91 +653,159 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				/* Recreate the failover slot and synchronize it */
+				NameData	plugin_name;
+				TransactionId xmin_horizon = InvalidTransactionId;
+
+				ereport(LOG,
+					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+					errmsg("slot \"%s\" already exists"
+					" on the standby but try to recreate it because "
+					"flag allow_overwrite is set to true",
+						remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotDrop(remote_slot->name,true);
+
+				/* Skip creating the local slot if remote_slot is invalidated already */
+				if (remote_slot->invalidated != RS_INVAL_NONE)
+					return false;
+
+				/*
+				* We create temporary slots instead of ephemeral slots here because
+				* we want the slots to survive after releasing them. This is done to
+				* avoid dropping and re-creating the slots in each synchronization
+				* cycle if the restart_lsn or catalog_xmin of the remote slot has not
+				* caught up.
+				*/
+				ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
+									remote_slot->two_phase,
+									remote_slot->failover,
+									true,
+									true);
+
+				/* For shorter lines. */
+				slot = MyReplicationSlot;
+
+				/* Avoid expensive operations while holding a spinlock. */
+				namestrcpy(&plugin_name, remote_slot->plugin);
+
+				SpinLockAcquire(&slot->mutex);
+				slot->data.database = remote_dbid;
+				slot->data.plugin = plugin_name;
+				SpinLockRelease(&slot->mutex);
+
+				reserve_wal_for_local_slot(remote_slot->restart_lsn);
+
+				LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+				xmin_horizon = GetOldestSafeDecodingTransactionId(true);
+				SpinLockAcquire(&slot->mutex);
+				slot->effective_catalog_xmin = xmin_horizon;
+				slot->data.catalog_xmin = xmin_horizon;
+				SpinLockRelease(&slot->mutex);
+				ReplicationSlotsComputeRequiredXmin(true);
+				LWLockRelease(ProcArrayLock);
+
+				update_and_persist_local_synced_slot(remote_slot, remote_dbid);
+
+				slot_updated = true;
+			}
+			else
+				ereport(ERROR,
 					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 					errmsg("exiting from slot synchronization because same"
 						   " name slot \"%s\" already exists on the standby",
 						   remote_slot->name));
-
-		/*
-		 * The slot has been synchronized before.
-		 *
-		 * It is important to acquire the slot here before checking
-		 * invalidation. If we don't acquire the slot first, there could be a
-		 * race condition that the local slot could be invalidated just after
-		 * checking the 'invalidated' flag here and we could end up
-		 * overwriting 'invalidated' flag to remote_slot's value. See
-		 * InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
-		 * if the slot is not acquired by other processes.
-		 *
-		 * XXX: If it ever turns out that slot acquire/release is costly for
-		 * cases when none of the slot properties is changed then we can do a
-		 * pre-check to ensure that at least one of the slot properties is
-		 * changed before acquiring the slot.
-		 */
-		ReplicationSlotAcquire(remote_slot->name, true, false);
-
-		Assert(slot == MyReplicationSlot);
-
-		/*
-		 * Copy the invalidation cause from remote only if local slot is not
-		 * invalidated locally, we don't want to overwrite existing one.
-		 */
-		if (slot->data.invalidated == RS_INVAL_NONE &&
-			remote_slot->invalidated != RS_INVAL_NONE)
+		}
+		else
 		{
-			SpinLockAcquire(&slot->mutex);
-			slot->data.invalidated = remote_slot->invalidated;
-			SpinLockRelease(&slot->mutex);
 
-			/* Make sure the invalidated state persists across server restart */
-			ReplicationSlotMarkDirty();
-			ReplicationSlotSave();
+			/*
+			* The slot has been synchronized before.
+			*
+			* It is important to acquire the slot here before checking
+			* invalidation. If we don't acquire the slot first, there could be a
+			* race condition that the local slot could be invalidated just after
+			* checking the 'invalidated' flag here and we could end up
+			* overwriting 'invalidated' flag to remote_slot's value. See
+			* InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
+			* if the slot is not acquired by other processes.
+			*
+			* XXX: If it ever turns out that slot acquire/release is costly for
+			* cases when none of the slot properties is changed then we can do a
+			* pre-check to ensure that at least one of the slot properties is
+			* changed before acquiring the slot.
+			*/
+			ReplicationSlotAcquire(remote_slot->name, true, false);
+
+			Assert(slot == MyReplicationSlot);
 
-			slot_updated = true;
-		}
+			/*
+			* Copy the invalidation cause from remote only if local slot is not
+			* invalidated locally, we don't want to overwrite existing one.
+			*/
+			if (slot->data.invalidated == RS_INVAL_NONE &&
+				remote_slot->invalidated != RS_INVAL_NONE)
+			{
+				SpinLockAcquire(&slot->mutex);
+				slot->data.invalidated = remote_slot->invalidated;
+				SpinLockRelease(&slot->mutex);
 
-		/* Skip the sync of an invalidated slot */
-		if (slot->data.invalidated != RS_INVAL_NONE)
-		{
-			ReplicationSlotRelease();
-			return slot_updated;
-		}
+				/* Make sure the invalidated state persists across server restart */
+				ReplicationSlotMarkDirty();
+				ReplicationSlotSave();
 
-		/* Slot not ready yet, let's attempt to make it sync-ready now. */
-		if (slot->data.persistency == RS_TEMPORARY)
-		{
-			slot_updated = update_and_persist_local_synced_slot(remote_slot,
-																remote_dbid);
-		}
+				slot_updated = true;
+			}
 
-		/* Slot ready for sync, so sync it. */
-		else
-		{
-			/*
-			 * Sanity check: As long as the invalidations are handled
-			 * appropriately as above, this should never happen.
-			 *
-			 * We don't need to check restart_lsn here. See the comments in
-			 * update_local_synced_slot() for details.
-			 */
-			if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
-				ereport(ERROR,
-						errmsg_internal("cannot synchronize local slot \"%s\"",
-										remote_slot->name),
-						errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
-										   LSN_FORMAT_ARGS(slot->data.confirmed_flush),
-										   LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
+			/* Skip the sync of an invalidated slot */
+			if (slot->data.invalidated != RS_INVAL_NONE)
+			{
+				ReplicationSlotRelease();
+				return slot_updated;
+			}
 
-			slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
-													NULL, NULL);
+			/* Slot not ready yet, let's attempt to make it sync-ready now. */
+			if (slot->data.persistency == RS_TEMPORARY)
+			{
+				slot_updated = update_and_persist_local_synced_slot(remote_slot,
+																	remote_dbid);
+			}
+
+			/* Slot ready for sync, so sync it. */
+			else
+			{
+				/*
+				* Sanity check: As long as the invalidations are handled
+				* appropriately as above, this should never happen.
+				*
+				* We don't need to check restart_lsn here. See the comments in
+				* update_local_synced_slot() for details.
+				*/
+				if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
+					ereport(ERROR,
+							errmsg_internal("cannot synchronize local slot \"%s\"",
+											remote_slot->name),
+							errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
+											LSN_FORMAT_ARGS(slot->data.confirmed_flush),
+											LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
+
+				slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
+														NULL, NULL);
+			}
 		}
 	}
 	/* Otherwise create the slot first. */
@@ -760,6 +828,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  true,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb9..fcba4d4 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f2115..1a50244 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -726,6 +728,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 59822f2..40586b2 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1202,7 +1202,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1233,7 +1233,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 01eba3b..fbaacfb 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11510,10 +11510,10 @@
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index fe62162..ca50b79 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From e99ef98faad4a2ff32daa4db36daceddf8225cf7 Mon Sep 17 00:00:00 2001
From: Shveta Malik <shveta.malik@gmail.com>
Date: Tue, 30 Sep 2025 14:54:41 +0530
Subject: [PATCH] refactored synchronize_one_slot

---
 src/backend/replication/logical/slotsync.c | 209 ++++++++-------------
 1 file changed, 82 insertions(+), 127 deletions(-)

diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index dbf9380cb39..a8d44fe6b45 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -649,6 +649,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		return false;
 	}
 
+retry:
 	/* Search for the named slot */
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
@@ -666,146 +667,100 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 			/* Check if we need to overwrite an existing logical slot */
 			if (allow_overwrite)
 			{
-				/* Recreate the failover slot and synchronize it */
-				NameData	plugin_name;
-				TransactionId xmin_horizon = InvalidTransactionId;
-
 				ereport(LOG,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("slot \"%s\" already exists"
-					" on the standby but try to recreate it because "
-					"flag allow_overwrite is set to true",
-						remote_slot->name));
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("slot \"%s\" already exists"
+							   " on the standby but will be overwritten as"
+							   " allow_overwrite is set to true",
+							   remote_slot->name));
 
 				/* Get rid of a replication slot that is no longer wanted */
-				ReplicationSlotDrop(remote_slot->name,true);
-
-				/* Skip creating the local slot if remote_slot is invalidated already */
-				if (remote_slot->invalidated != RS_INVAL_NONE)
-					return false;
-
-				/*
-				* We create temporary slots instead of ephemeral slots here because
-				* we want the slots to survive after releasing them. This is done to
-				* avoid dropping and re-creating the slots in each synchronization
-				* cycle if the restart_lsn or catalog_xmin of the remote slot has not
-				* caught up.
-				*/
-				ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
-									remote_slot->two_phase,
-									remote_slot->failover,
-									true,
-									true);
-
-				/* For shorter lines. */
-				slot = MyReplicationSlot;
-
-				/* Avoid expensive operations while holding a spinlock. */
-				namestrcpy(&plugin_name, remote_slot->plugin);
-
-				SpinLockAcquire(&slot->mutex);
-				slot->data.database = remote_dbid;
-				slot->data.plugin = plugin_name;
-				SpinLockRelease(&slot->mutex);
-
-				reserve_wal_for_local_slot(remote_slot->restart_lsn);
-
-				LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
-				xmin_horizon = GetOldestSafeDecodingTransactionId(true);
-				SpinLockAcquire(&slot->mutex);
-				slot->effective_catalog_xmin = xmin_horizon;
-				slot->data.catalog_xmin = xmin_horizon;
-				SpinLockRelease(&slot->mutex);
-				ReplicationSlotsComputeRequiredXmin(true);
-				LWLockRelease(ProcArrayLock);
-
-				update_and_persist_local_synced_slot(remote_slot, remote_dbid);
-
-				slot_updated = true;
+				ReplicationSlotAcquire(remote_slot->name, true, false);
+				ReplicationSlotDropAcquired();
+				goto retry;
 			}
 			else
+			{
 				ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+			}
 		}
-		else
-		{
 
-			/*
-			* The slot has been synchronized before.
-			*
-			* It is important to acquire the slot here before checking
-			* invalidation. If we don't acquire the slot first, there could be a
-			* race condition that the local slot could be invalidated just after
-			* checking the 'invalidated' flag here and we could end up
-			* overwriting 'invalidated' flag to remote_slot's value. See
-			* InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
-			* if the slot is not acquired by other processes.
-			*
-			* XXX: If it ever turns out that slot acquire/release is costly for
-			* cases when none of the slot properties is changed then we can do a
-			* pre-check to ensure that at least one of the slot properties is
-			* changed before acquiring the slot.
-			*/
-			ReplicationSlotAcquire(remote_slot->name, true, false);
-
-			Assert(slot == MyReplicationSlot);
+		/*
+		 * The slot has been synchronized before.
+		 *
+		 * It is important to acquire the slot here before checking
+		 * invalidation. If we don't acquire the slot first, there could be a
+		 * race condition that the local slot could be invalidated just after
+		 * checking the 'invalidated' flag here and we could end up
+		 * overwriting 'invalidated' flag to remote_slot's value. See
+		 * InvalidatePossiblyObsoleteSlot() where it invalidates slot directly
+		 * if the slot is not acquired by other processes.
+		 *
+		 * XXX: If it ever turns out that slot acquire/release is costly for
+		 * cases when none of the slot properties is changed then we can do a
+		 * pre-check to ensure that at least one of the slot properties is
+		 * changed before acquiring the slot.
+		 */
+		ReplicationSlotAcquire(remote_slot->name, true, false);
 
-			/*
-			* Copy the invalidation cause from remote only if local slot is not
-			* invalidated locally, we don't want to overwrite existing one.
-			*/
-			if (slot->data.invalidated == RS_INVAL_NONE &&
-				remote_slot->invalidated != RS_INVAL_NONE)
-			{
-				SpinLockAcquire(&slot->mutex);
-				slot->data.invalidated = remote_slot->invalidated;
-				SpinLockRelease(&slot->mutex);
+		Assert(slot == MyReplicationSlot);
 
-				/* Make sure the invalidated state persists across server restart */
-				ReplicationSlotMarkDirty();
-				ReplicationSlotSave();
+		/*
+		 * Copy the invalidation cause from remote only if local slot is not
+		 * invalidated locally, we don't want to overwrite existing one.
+		 */
+		if (slot->data.invalidated == RS_INVAL_NONE &&
+			remote_slot->invalidated != RS_INVAL_NONE)
+		{
+			SpinLockAcquire(&slot->mutex);
+			slot->data.invalidated = remote_slot->invalidated;
+			SpinLockRelease(&slot->mutex);
 
-				slot_updated = true;
-			}
+			/* Make sure the invalidated state persists across server restart */
+			ReplicationSlotMarkDirty();
+			ReplicationSlotSave();
 
-			/* Skip the sync of an invalidated slot */
-			if (slot->data.invalidated != RS_INVAL_NONE)
-			{
-				ReplicationSlotRelease();
-				return slot_updated;
-			}
+			slot_updated = true;
+		}
 
-			/* Slot not ready yet, let's attempt to make it sync-ready now. */
-			if (slot->data.persistency == RS_TEMPORARY)
-			{
-				slot_updated = update_and_persist_local_synced_slot(remote_slot,
-																	remote_dbid);
-			}
+		/* Skip the sync of an invalidated slot */
+		if (slot->data.invalidated != RS_INVAL_NONE)
+		{
+			ReplicationSlotRelease();
+			return slot_updated;
+		}
 
-			/* Slot ready for sync, so sync it. */
-			else
-			{
-				/*
-				* Sanity check: As long as the invalidations are handled
-				* appropriately as above, this should never happen.
-				*
-				* We don't need to check restart_lsn here. See the comments in
-				* update_local_synced_slot() for details.
-				*/
-				if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
-					ereport(ERROR,
-							errmsg_internal("cannot synchronize local slot \"%s\"",
-											remote_slot->name),
-							errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
-											LSN_FORMAT_ARGS(slot->data.confirmed_flush),
-											LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
-
-				slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
-														NULL, NULL);
-			}
+		/* Slot not ready yet, let's attempt to make it sync-ready now. */
+		if (slot->data.persistency == RS_TEMPORARY)
+		{
+			slot_updated = update_and_persist_local_synced_slot(remote_slot,
+																remote_dbid);
+		}
+
+		/* Slot ready for sync, so sync it. */
+		else
+		{
+			/*
+			 * Sanity check: As long as the invalidations are handled
+			 * appropriately as above, this should never happen.
+			 *
+			 * We don't need to check restart_lsn here. See the comments in
+			 * update_local_synced_slot() for details.
+			 */
+			if (remote_slot->confirmed_lsn < slot->data.confirmed_flush)
+				ereport(ERROR,
+						errmsg_internal("cannot synchronize local slot \"%s\"",
+										remote_slot->name),
+						errdetail_internal("Local slot's start streaming location LSN(%X/%08X) is ahead of remote slot's LSN(%X/%08X).",
+										   LSN_FORMAT_ARGS(slot->data.confirmed_flush),
+										   LSN_FORMAT_ARGS(remote_slot->confirmed_lsn)));
+
+			slot_updated = update_local_synced_slot(remote_slot, remote_dbid,
+													NULL, NULL);
 		}
 	}
 	/* Otherwise create the slot first. */
@@ -828,7 +783,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
-							  true,
+							  false,
 							  true);
 
 		/* For shorter lines. */
-- 
2.34.1

From 3723bae39873517e185577acf0c3ca82c08edd3c Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Mon, 29 Sep 2025 13:10:38 +0200
Subject: [PATCH v3] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.

Signed-off-by: Fabrice Chapuis <fabrice636861@gmail.com>
---
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/replication/logical/launcher.c |  2 +-
 src/backend/replication/logical/slotsync.c | 34 ++++++++++++++++++----
 src/backend/replication/slot.c             |  3 +-
 src/backend/replication/slotfuncs.c        |  9 ++++--
 src/backend/replication/walsender.c        |  4 +--
 src/include/catalog/pg_proc.dat            |  8 ++---
 src/include/replication/slot.h             |  8 ++++-
 8 files changed, 52 insertions(+), 17 deletions(-)

diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 2d946d6..75ea84f 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 218cefe..a26af52 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1519,7 +1519,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	init_conflict_slot_xmin();
 }
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d5..a8d44fe 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -649,22 +649,45 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		return false;
 	}
 
+retry:
 	/* Search for the named slot */
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				ereport(LOG,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("slot \"%s\" already exists"
+							   " on the standby but will be overwritten as"
+							   " allow_overwrite is set to true",
+							   remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotAcquire(remote_slot->name, true, false);
+				ReplicationSlotDropAcquired();
+				goto retry;
+			}
+			else
+			{
+				ereport(ERROR,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+			}
+		}
 
 		/*
 		 * The slot has been synchronized before.
@@ -760,6 +783,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  false,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb9..fcba4d4 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f2115..1a50244 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -726,6 +728,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 59822f2..40586b2 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1202,7 +1202,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1233,7 +1233,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 01eba3b..fbaacfb 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11510,10 +11510,10 @@
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index fe62162..ca50b79 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From 25e513bf49f3afe4b6ed7333ae46705c357eeb47 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Mon, 29 Sep 2025 13:10:38 +0200
Subject: [PATCH v4] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.

Signed-off-by: Fabrice Chapuis <fabrice636861@gmail.com>
---
 doc/src/sgml/system-views.sgml             | 12 ++++++++
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/catalog/system_views.sql       |  3 +-
 src/backend/replication/logical/launcher.c |  2 +-
 src/backend/replication/logical/slotsync.c | 34 ++++++++++++++++++----
 src/backend/replication/slot.c             |  3 +-
 src/backend/replication/slotfuncs.c        | 13 ++++++---
 src/backend/replication/walsender.c        |  4 +--
 src/include/catalog/pg_proc.dat            | 14 ++++-----
 src/include/replication/slot.h             |  8 ++++-
 10 files changed, 72 insertions(+), 22 deletions(-)

diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 4187191ea74..0d94622cd0c 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -3036,6 +3036,18 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx
       </para></entry>
      </row>
 
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>allow_overwrite</structfield> <type>bool</type>
+      </para>
+      <para>
+       The parameter controls whether existing logical replication slot metadata may
+       be overwritten on the standby instance. The default is <literal>false</literal>.
+       When true, an existing failover slot on standby instance will be dropped and replaced
+       automatically.
+      </para></entry>
+     </row>     
+
     </tbody>
    </tgroup>
   </table>
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 2d946d6d9e9..75ea84fd837 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index c77fa0234bb..7fc42ddbe66 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1046,7 +1046,8 @@ CREATE VIEW pg_replication_slots AS
             L.conflicting,
             L.invalidation_reason,
             L.failover,
-            L.synced
+            L.synced,
+            L.allow_overwrite
     FROM pg_get_replication_slots() AS L
             LEFT JOIN pg_database D ON (L.datoid = D.oid);
 
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 218cefe86e2..a26af527775 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1519,7 +1519,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	init_conflict_slot_xmin();
 }
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d55bdb..a8d44fe6b45 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -649,22 +649,45 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		return false;
 	}
 
+retry:
 	/* Search for the named slot */
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				ereport(LOG,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("slot \"%s\" already exists"
+							   " on the standby but will be overwritten as"
+							   " allow_overwrite is set to true",
+							   remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotAcquire(remote_slot->name, true, false);
+				ReplicationSlotDropAcquired();
+				goto retry;
+			}
+			else
+			{
+				ereport(ERROR,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+			}
+		}
 
 		/*
 		 * The slot has been synchronized before.
@@ -760,6 +783,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  false,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb96d42..fcba4d4cff9 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f21153e7b..6a6a03e9a4d 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -235,7 +237,7 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS)
 Datum
 pg_get_replication_slots(PG_FUNCTION_ARGS)
 {
-#define PG_GET_REPLICATION_SLOTS_COLS 20
+#define PG_GET_REPLICATION_SLOTS_COLS 21
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	XLogRecPtr	currlsn;
 	int			slotno;
@@ -443,6 +445,8 @@ pg_get_replication_slots(PG_FUNCTION_ARGS)
 
 		values[i++] = BoolGetDatum(slot_contents.data.synced);
 
+		values[i++] = BoolGetDatum(slot_contents.data.allow_overwrite);
+
 		Assert(i == PG_GET_REPLICATION_SLOTS_COLS);
 
 		tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
@@ -726,6 +730,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 59822f22b8d..40586b273ba 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1202,7 +1202,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1233,7 +1233,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 01eba3b5a19..2f980c0dd4f 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11503,17 +11503,17 @@
   proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f',
   proretset => 't', provolatile => 's', prorettype => 'record',
   proargtypes => '',
-  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool}',
-  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
-  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced}',
+  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool,bool}',
+  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
+  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced,allow_overwrite}',
   prosrc => 'pg_get_replication_slots' },
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index fe62162cde3..ca50b79daaa 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.39.5

From 68bda4e973c95ff9d24a6fc866187903d04d3d21 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Mon, 29 Sep 2025 13:10:38 +0200
Subject: [PATCH v5] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.

Signed-off-by: Fabrice Chapuis <fabrice636861@gmail.com>
---
 doc/src/sgml/system-views.sgml             | 14 +++++++++
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/catalog/system_views.sql       |  3 +-
 src/backend/replication/logical/launcher.c |  2 +-
 src/backend/replication/logical/slotsync.c | 34 ++++++++++++++++++----
 src/backend/replication/slot.c             |  3 +-
 src/backend/replication/slotfuncs.c        | 13 ++++++---
 src/backend/replication/walsender.c        |  4 +--
 src/include/catalog/pg_proc.dat            | 14 ++++-----
 src/include/replication/slot.h             |  8 ++++-
 10 files changed, 74 insertions(+), 22 deletions(-)

diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 4187191ea74..1a7bb7d2a4b 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -3036,6 +3036,20 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx
       </para></entry>
      </row>
 
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>allow_overwrite</structfield> <type>bool</type>
+      </para>
+      <para>
+       This parameter controls whether an existing logical replication slot
+       on the standby (with synced=false) can be overwritten during logical
+       replication slot synchronization (see
+       <xref linkend="logicaldecoding-replication-slots-synchronization"/>). The default is
+       <literal>false</literal>. When <literal>true</literal>, an existing user slot with the same name on the
+       standby will be synchronized using the primary’s failover slot.
+      </para></entry>
+     </row>     
+
     </tbody>
    </tgroup>
   </table>
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 2d946d6d9e9..75ea84fd837 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index c77fa0234bb..7fc42ddbe66 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1046,7 +1046,8 @@ CREATE VIEW pg_replication_slots AS
             L.conflicting,
             L.invalidation_reason,
             L.failover,
-            L.synced
+            L.synced,
+            L.allow_overwrite
     FROM pg_get_replication_slots() AS L
             LEFT JOIN pg_database D ON (L.datoid = D.oid);
 
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 218cefe86e2..a26af527775 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1519,7 +1519,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	init_conflict_slot_xmin();
 }
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d55bdb..a8d44fe6b45 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -649,22 +649,45 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		return false;
 	}
 
+retry:
 	/* Search for the named slot */
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				ereport(LOG,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("slot \"%s\" already exists"
+							   " on the standby but will be overwritten as"
+							   " allow_overwrite is set to true",
+							   remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotAcquire(remote_slot->name, true, false);
+				ReplicationSlotDropAcquired();
+				goto retry;
+			}
+			else
+			{
+				ereport(ERROR,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+			}
+		}
 
 		/*
 		 * The slot has been synchronized before.
@@ -760,6 +783,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  false,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index fd0fdb96d42..fcba4d4cff9 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f21153e7b..6a6a03e9a4d 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -235,7 +237,7 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS)
 Datum
 pg_get_replication_slots(PG_FUNCTION_ARGS)
 {
-#define PG_GET_REPLICATION_SLOTS_COLS 20
+#define PG_GET_REPLICATION_SLOTS_COLS 21
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	XLogRecPtr	currlsn;
 	int			slotno;
@@ -443,6 +445,8 @@ pg_get_replication_slots(PG_FUNCTION_ARGS)
 
 		values[i++] = BoolGetDatum(slot_contents.data.synced);
 
+		values[i++] = BoolGetDatum(slot_contents.data.allow_overwrite);
+
 		Assert(i == PG_GET_REPLICATION_SLOTS_COLS);
 
 		tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
@@ -726,6 +730,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 59822f22b8d..40586b273ba 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1202,7 +1202,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1233,7 +1233,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 01eba3b5a19..2f980c0dd4f 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11503,17 +11503,17 @@
   proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f',
   proretset => 't', provolatile => 's', prorettype => 'record',
   proargtypes => '',
-  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool}',
-  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
-  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced}',
+  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool,bool}',
+  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
+  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced,allow_overwrite}',
   prosrc => 'pg_get_replication_slots' },
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index fe62162cde3..ca50b79daaa 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.39.5

From 05fb2b5a254c82d49459c018ab2702730bc0d791 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Wed, 15 Oct 2025 11:50:44 +0200
Subject: [PATCH v6] Add allow_overwrite option to logical replication slot
 creation

This patch adds a new parameter allow_overwrite to
pg_create_logical_replication_slot. When true, an existing
failover slot on standby will be dropped and replaced
automatically.
---
 doc/src/sgml/system-views.sgml             | 15 ++++++++++
 src/backend/catalog/system_functions.sql   |  1 +
 src/backend/catalog/system_views.sql       |  3 +-
 src/backend/replication/logical/launcher.c |  2 +-
 src/backend/replication/logical/slotsync.c | 34 ++++++++++++++++++----
 src/backend/replication/slot.c             |  3 +-
 src/backend/replication/slotfuncs.c        | 13 ++++++---
 src/backend/replication/walsender.c        |  4 +--
 src/include/catalog/pg_proc.dat            | 14 ++++-----
 src/include/replication/slot.h             |  8 ++++-
 10 files changed, 75 insertions(+), 22 deletions(-)

diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 7971498..41cbf3f 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -3102,6 +3102,21 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx
       </para></entry>
      </row>
 
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>allow_overwrite</structfield> <type>bool</type>
+      </para>
+      <para>
+       This parameter controls whether an existing logical replication slot
+       on the standby (with <structfield>synced</structfield> field as <literal>false</literal>)
+       can be overwritten during logical
+       replication slot synchronization (see
+       <xref linkend="logicaldecoding-replication-slots-synchronization"/>). The default is
+       <literal>false</literal>. When <literal>true</literal>, an existing user slot with the same name on the
+       standby will be synchronized using the primary’s failover slot.
+      </para></entry>
+     </row>
+
     </tbody>
    </tgroup>
   </table>
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index 2d946d6..75ea84f 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -480,6 +480,7 @@ CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
     IN temporary boolean DEFAULT false,
     IN twophase boolean DEFAULT false,
     IN failover boolean DEFAULT false,
+    IN allow_overwrite boolean DEFAULT false,
     OUT slot_name name, OUT lsn pg_lsn)
 RETURNS RECORD
 LANGUAGE INTERNAL
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 823776c..9203d08 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1060,7 +1060,8 @@ CREATE VIEW pg_replication_slots AS
             L.conflicting,
             L.invalidation_reason,
             L.failover,
-            L.synced
+            L.synced,
+            L.allow_overwrite
     FROM pg_get_replication_slots() AS L
             LEFT JOIN pg_database D ON (L.datoid = D.oid);
 
diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c
index 218cefe..a26af52 100644
--- a/src/backend/replication/logical/launcher.c
+++ b/src/backend/replication/logical/launcher.c
@@ -1519,7 +1519,7 @@ CreateConflictDetectionSlot(void)
 			errmsg("creating replication conflict detection slot"));
 
 	ReplicationSlotCreate(CONFLICT_DETECTION_SLOT, false, RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	init_conflict_slot_xmin();
 }
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d5..a8d44fe 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -649,22 +649,45 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		return false;
 	}
 
+retry:
 	/* Search for the named slot */
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		allow_overwrite;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		allow_overwrite = slot->data.allow_overwrite;
 		SpinLockRelease(&slot->mutex);
 
 		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+		{
+			/* Check if we need to overwrite an existing logical slot */
+			if (allow_overwrite)
+			{
+				ereport(LOG,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("slot \"%s\" already exists"
+							   " on the standby but will be overwritten as"
+							   " allow_overwrite is set to true",
+							   remote_slot->name));
+
+				/* Get rid of a replication slot that is no longer wanted */
+				ReplicationSlotAcquire(remote_slot->name, true, false);
+				ReplicationSlotDropAcquired();
+				goto retry;
+			}
+			else
+			{
+				ereport(ERROR,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+			}
+		}
 
 		/*
 		 * The slot has been synchronized before.
@@ -760,6 +783,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 		ReplicationSlotCreate(remote_slot->name, true, RS_TEMPORARY,
 							  remote_slot->two_phase,
 							  remote_slot->failover,
+							  false,
 							  true);
 
 		/* For shorter lines. */
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index ac188bb..84a1838 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -351,7 +351,7 @@ IsSlotForConflictCheck(const char *name)
 void
 ReplicationSlotCreate(const char *name, bool db_specific,
 					  ReplicationSlotPersistency persistency,
-					  bool two_phase, bool failover, bool synced)
+					  bool two_phase, bool failover, bool allow_overwrite, bool synced)
 {
 	ReplicationSlot *slot = NULL;
 	int			i;
@@ -445,6 +445,7 @@ ReplicationSlotCreate(const char *name, bool db_specific,
 	slot->data.two_phase = two_phase;
 	slot->data.two_phase_at = InvalidXLogRecPtr;
 	slot->data.failover = failover;
+	slot->data.allow_overwrite = allow_overwrite;
 	slot->data.synced = synced;
 
 	/* and then data only present in shared memory */
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f2115..6a6a03e 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -41,7 +41,7 @@ create_physical_replication_slot(char *name, bool immediately_reserve,
 	/* acquire replication slot, this will check for conflicting names */
 	ReplicationSlotCreate(name, false,
 						  temporary ? RS_TEMPORARY : RS_PERSISTENT, false,
-						  false, false);
+						  false, false, false);
 
 	if (immediately_reserve)
 	{
@@ -116,7 +116,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
 static void
 create_logical_replication_slot(char *name, char *plugin,
 								bool temporary, bool two_phase,
-								bool failover,
+								bool failover, bool allow_overwrite,
 								XLogRecPtr restart_lsn,
 								bool find_startpoint)
 {
@@ -134,7 +134,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	 */
 	ReplicationSlotCreate(name, true,
 						  temporary ? RS_TEMPORARY : RS_EPHEMERAL, two_phase,
-						  failover, false);
+						  failover, allow_overwrite, false);
 
 	/*
 	 * Create logical decoding context to find start point or, if we don't
@@ -173,6 +173,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 	bool		temporary = PG_GETARG_BOOL(2);
 	bool		two_phase = PG_GETARG_BOOL(3);
 	bool		failover = PG_GETARG_BOOL(4);
+	bool		allow_overwrite = PG_GETARG_BOOL(5);
 	Datum		result;
 	TupleDesc	tupdesc;
 	HeapTuple	tuple;
@@ -191,6 +192,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS)
 									temporary,
 									two_phase,
 									failover,
+									allow_overwrite,
 									InvalidXLogRecPtr,
 									true);
 
@@ -235,7 +237,7 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS)
 Datum
 pg_get_replication_slots(PG_FUNCTION_ARGS)
 {
-#define PG_GET_REPLICATION_SLOTS_COLS 20
+#define PG_GET_REPLICATION_SLOTS_COLS 21
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	XLogRecPtr	currlsn;
 	int			slotno;
@@ -443,6 +445,8 @@ pg_get_replication_slots(PG_FUNCTION_ARGS)
 
 		values[i++] = BoolGetDatum(slot_contents.data.synced);
 
+		values[i++] = BoolGetDatum(slot_contents.data.allow_overwrite);
+
 		Assert(i == PG_GET_REPLICATION_SLOTS_COLS);
 
 		tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
@@ -726,6 +730,7 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot)
 										temporary,
 										false,
 										false,
+										false,
 										src_restart_lsn,
 										false);
 	}
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 59822f2..40586b2 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1202,7 +1202,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 	{
 		ReplicationSlotCreate(cmd->slotname, false,
 							  cmd->temporary ? RS_TEMPORARY : RS_PERSISTENT,
-							  false, false, false);
+							  false, false, false, false);
 
 		if (reserve_wal)
 		{
@@ -1233,7 +1233,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
 		 */
 		ReplicationSlotCreate(cmd->slotname, true,
 							  cmd->temporary ? RS_TEMPORARY : RS_EPHEMERAL,
-							  two_phase, failover, false);
+							  two_phase, failover, false, false);
 
 		/*
 		 * Do options check early so that we can bail before calling the
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index b51d2b1..8ef7619 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -11511,17 +11511,17 @@
   proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f',
   proretset => 't', provolatile => 's', prorettype => 'record',
   proargtypes => '',
-  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool}',
-  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
-  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced}',
+  proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool,bool}',
+  proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
+  proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced,allow_overwrite}',
   prosrc => 'pg_get_replication_slots' },
 { oid => '3786', descr => 'set up a logical replication slot',
   proname => 'pg_create_logical_replication_slot', provolatile => 'v',
   proparallel => 'u', prorettype => 'record',
-  proargtypes => 'name name bool bool bool',
-  proallargtypes => '{name,name,bool,bool,bool,name,pg_lsn}',
-  proargmodes => '{i,i,i,i,i,o,o}',
-  proargnames => '{slot_name,plugin,temporary,twophase,failover,slot_name,lsn}',
+  proargtypes => 'name name bool bool bool bool',
+  proallargtypes => '{name,name,bool,bool,bool,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,twophase,failover,allow_overwrite,slot_name,lsn}',
   prosrc => 'pg_create_logical_replication_slot' },
 { oid => '4222',
   descr => 'copy a logical replication slot, changing temporality and plugin',
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index fe62162..ca50b79 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -141,6 +141,12 @@ typedef struct ReplicationSlotPersistentData
 	 * for logical slots on the primary server.
 	 */
 	bool		failover;
+
+	/*
+	 * Allow Postgres to drop logical replication slot on standby server to ensure
+	 * creation of new failover slot when remote sync_replication_slots is set to true.
+	 */
+	bool		allow_overwrite;
 } ReplicationSlotPersistentData;
 
 /*
@@ -301,7 +307,7 @@ extern void ReplicationSlotsShmemInit(void);
 /* management of individual slots */
 extern void ReplicationSlotCreate(const char *name, bool db_specific,
 								  ReplicationSlotPersistency persistency,
-								  bool two_phase, bool failover,
+								  bool two_phase, bool failover, bool allow_overwrite,
 								  bool synced);
 extern void ReplicationSlotPersist(void);
 extern void ReplicationSlotDrop(const char *name, bool nowait);
-- 
2.47.3

From 469324c263c5ee09ae0f6d75761e2607e08a9e67 Mon Sep 17 00:00:00 2001
From: Alexander Kukushkin <cyberdemn@gmail.com>
Date: Tue, 28 Oct 2025 13:32:43 +0100
Subject: [PATCH] Continue slots synchronization after switchover

When the former primary is started up after clean shutdown as a standby
it was refusing to synchronize logical failover slots because synced is
false with the error: "exiting from slot synchronization because same
name slot "<name>" already exists on the standby".

Since we don't allow creation of logical replication slots with
failover=true on standby it is safe to check that replication slot
has failover=true and in this case set synced=true and continue.

Besides that, we change filter in drop_local_obsolete_slots() function,
because 'failover' better defines purpose of the slot.
---
 src/backend/replication/logical/slotsync.c | 31 ++++++++++++++++------
 1 file changed, 23 insertions(+), 8 deletions(-)

diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index b122d99b009..55d6f2fb9e9 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -455,10 +455,11 @@ drop_local_obsolete_slots(List *remote_slot_list)
 			 * slot by the user. This new user-created slot may end up using
 			 * the same shared memory as that of 'local_slot'. Thus check if
 			 * local_slot is still the synced one before performing actual
-			 * drop.
+			 * drop. Yes, we actually check 'failover', not 'synced', because
+			 * it could have been created on primary which is now a standby.
 			 */
 			SpinLockAcquire(&local_slot->mutex);
-			synced_slot = local_slot->in_use && local_slot->data.synced;
+			synced_slot = local_slot->in_use && local_slot->data.failover;
 			SpinLockRelease(&local_slot->mutex);
 
 			if (synced_slot)
@@ -653,18 +654,32 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	if ((slot = SearchNamedReplicationSlot(remote_slot->name, true)))
 	{
 		bool		synced;
+		bool		failover;
 
 		SpinLockAcquire(&slot->mutex);
 		synced = slot->data.synced;
+		failover = slot->data.failover;
 		SpinLockRelease(&slot->mutex);
 
-		/* User-created slot with the same name exists, raise ERROR. */
 		if (!synced)
-			ereport(ERROR,
-					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					errmsg("exiting from slot synchronization because same"
-						   " name slot \"%s\" already exists on the standby",
-						   remote_slot->name));
+		{
+			/* User-created slot with the same name exists, raise ERROR. */
+			if (!failover)
+				ereport(ERROR,
+						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						errmsg("exiting from slot synchronization because same"
+							   " name slot \"%s\" already exists on the standby",
+							   remote_slot->name));
+
+			/*
+			 * At some point we were a primary, and it was expected to have
+			 * synced = false and failover = true. In this case we want to set
+			 * synced = true and continue synchronization.
+			 */
+			SpinLockAcquire(&slot->mutex);
+			slot->data.synced = true;
+			SpinLockRelease(&slot->mutex);
+		}
 
 		/*
 		 * The slot has been synchronized before.
-- 
2.34.1

From 07beefc31a07cec4fcc81687be49c563fa359f84 Mon Sep 17 00:00:00 2001
From: Fabrice Chapuis <fabrice636861@gmail.com>
Date: Fri, 7 Nov 2025 18:04:15 +0100
Subject: [PATCH v1] Resync logical replication slot after switchover

When the former primary is started up after clean shutdown,
it was refusing to synchronize the logical failover slots with the new primary
because synced flag is false.
The following error message is produced: "exiting from slot synchronization because same
slot name already exists on the standby".

If local slot has failover=true, it can be overwrite to be synced with
the primary.

This patch mainly change the drop_local_obsolete_slots() function and
check that a local failover slot could be dropped.
---
 src/backend/replication/logical/slotsync.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 8c061d5..16e20d4 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -341,7 +341,7 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid,
 }
 
 /*
- * Get the list of local logical slots that are synchronized from the
+ * Get the list of local logical slots that are synchronized or not with the
  * primary server.
  */
 static List *
@@ -356,7 +356,7 @@ get_local_synced_slots(void)
 		ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
 
 		/* Check if it is a synchronized slot */
-		if (s->in_use && s->data.synced)
+		if (s->in_use && (s->data.synced || s->data.failover))
 		{
 			Assert(SlotIsLogical(s));
 			local_slots = lappend(local_slots, s);
@@ -380,6 +380,7 @@ local_sync_slot_required(ReplicationSlot *local_slot, List *remote_slots)
 {
 	bool		remote_exists = false;
 	bool		locally_invalidated = false;
+	bool		synced_slot = false;
 
 	foreach_ptr(RemoteSlot, remote_slot, remote_slots)
 	{
@@ -395,13 +396,14 @@ local_sync_slot_required(ReplicationSlot *local_slot, List *remote_slots)
 			locally_invalidated =
 				(remote_slot->invalidated == RS_INVAL_NONE) &&
 				(local_slot->data.invalidated != RS_INVAL_NONE);
+			synced_slot = local_slot->data.synced;
 			SpinLockRelease(&local_slot->mutex);
 
 			break;
 		}
 	}
 
-	return (remote_exists && !locally_invalidated);
+	return (remote_exists && !locally_invalidated && synced_slot);
 }
 
 /*
@@ -455,10 +457,12 @@ drop_local_obsolete_slots(List *remote_slot_list)
 			 * slot by the user. This new user-created slot may end up using
 			 * the same shared memory as that of 'local_slot'. Thus check if
 			 * local_slot is still the synced one before performing actual
-			 * drop.
+			 * drop. Yes, we actually check 'failover', not 'synced', because
+			 * it could have been created on primary which is now a standby.
 			 */
+
 			SpinLockAcquire(&local_slot->mutex);
-			synced_slot = local_slot->in_use && local_slot->data.synced;
+			synced_slot = local_slot->in_use && (local_slot->data.failover || local_slot->data.synced);
 			SpinLockRelease(&local_slot->mutex);
 
 			if (synced_slot)
-- 
2.47.3