From b1b3d32ea1836048a9688dea20405a8e1b6d15f3 Mon Sep 17 00:00:00 2001
From: Hou Zhijie <houzj.fnst@cn.fujitsu.com>
Date: Wed, 26 Jun 2024 11:13:55 +0800
Subject: [PATCH v2] Rename standby_slot_names to synchronized_standby_slots

The standby_slot_names GUC allows specification of physical
standby slots that must be synchronized before they are visible to
subscribers, but the name seems too generic.

To avoid confusion, rename it to 'synchronized_standby_slots' which better
aligns with the concept of synchronization.
---
 doc/src/sgml/config.sgml                      |  12 +-
 doc/src/sgml/func.sgml                        |   4 +-
 doc/src/sgml/logical-replication.sgml         |   2 +-
 doc/src/sgml/logicaldecoding.sgml             |   8 +-
 src/backend/replication/logical/slotsync.c    |   4 +-
 src/backend/replication/slot.c                | 119 +++++++++---------
 src/backend/replication/walsender.c           |   4 +-
 src/backend/utils/misc/guc_tables.c           |   6 +-
 src/backend/utils/misc/postgresql.conf.sample |   4 +-
 src/include/replication/slot.h                |   4 +-
 src/include/replication/walsender_private.h   |   4 +-
 src/include/utils/guc_hooks.h                 |   6 +-
 .../t/040_standby_failover_slots_sync.pl      |  48 +++----
 src/tools/pgindent/typedefs.list              |   2 +-
 14 files changed, 115 insertions(+), 112 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 0c7a9082c5..17d84bd321 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -4569,10 +4569,10 @@ restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"'  # Windows
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-standby-slot-names" xreflabel="standby_slot_names">
-      <term><varname>standby_slot_names</varname> (<type>string</type>)
+     <varlistentry id="guc-synchronized-standby-slots" xreflabel="synchronized_standby_slots">
+      <term><varname>synchronized_standby_slots</varname> (<type>string</type>)
       <indexterm>
-       <primary><varname>standby_slot_names</varname> configuration parameter</primary>
+       <primary><varname>synchronized_standby_slots</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
@@ -4587,7 +4587,7 @@ restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"'  # Windows
         after the standby is promoted, the physical replication slot for the
         standby should be listed here. Note that logical replication will not
         proceed if the slots specified in the
-        <varname>standby_slot_names</varname> do not exist or are invalidated.
+        <varname>synchronized_standby_slots</varname> do not exist or are invalidated.
         Additionally, the replication management functions
         <link linkend="pg-replication-slot-advance">
         <function>pg_replication_slot_advance</function></link>,
@@ -4596,12 +4596,12 @@ restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"'  # Windows
         <link linkend="pg-logical-slot-peek-changes">
         <function>pg_logical_slot_peek_changes</function></link>,
         when used with logical failover slots, will block until all
-        physical slots specified in <varname>standby_slot_names</varname> have
+        physical slots specified in <varname>synchronized_standby_slots</varname> have
         confirmed WAL receipt.
        </para>
        <para>
         The standbys corresponding to the physical replication slots in
-        <varname>standby_slot_names</varname> must configure
+        <varname>synchronized_standby_slots</varname> must configure
         <literal>sync_replication_slots = true</literal> so they can receive
         logical failover slot changes from the primary.
        </para>
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 2609269610..1486db696e 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29047,7 +29047,7 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
         adding the rows produced when decoding each new transaction commit.
         If the specified slot is a logical failover slot then the function will
         not return until all physical slots specified in
-        <link linkend="guc-standby-slot-names"><varname>standby_slot_names</varname></link>
+        <link linkend="guc-synchronized-standby-slots"><varname>synchronized_standby_slots</varname></link>
         have confirmed WAL receipt.
        </para></entry>
       </row>
@@ -29127,7 +29127,7 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
         slot may return to an earlier position. If the specified slot is a
         logical failover slot then the function will not return until all
         physical slots specified in
-        <link linkend="guc-standby-slot-names"><varname>standby_slot_names</varname></link>
+        <link linkend="guc-synchronized-standby-slots"><varname>synchronized_standby_slots</varname></link>
         have confirmed WAL receipt.
        </para></entry>
       </row>
diff --git a/doc/src/sgml/logical-replication.sgml b/doc/src/sgml/logical-replication.sgml
index 746d5bd330..ccdd24312b 100644
--- a/doc/src/sgml/logical-replication.sgml
+++ b/doc/src/sgml/logical-replication.sgml
@@ -713,7 +713,7 @@ ALTER SUBSCRIPTION
    server before the failover happens. To ensure a successful failover, the
    standby server must be ahead of the subscriber. This can be achieved by
    configuring
-   <link linkend="guc-standby-slot-names"><varname>standby_slot_names</varname></link>.
+   <link linkend="guc-synchronized-standby-slots"><varname>synchronized_standby_slots</varname></link>.
   </para>
 
   <para>
diff --git a/doc/src/sgml/logicaldecoding.sgml b/doc/src/sgml/logicaldecoding.sgml
index 5a15bbc580..1c4ae38f1b 100644
--- a/doc/src/sgml/logicaldecoding.sgml
+++ b/doc/src/sgml/logicaldecoding.sgml
@@ -385,16 +385,16 @@ postgres=# select * from pg_logical_slot_get_changes('regression_slot', NULL, NU
      <literal>dbname</literal> in the
      <link linkend="guc-primary-conninfo"><varname>primary_conninfo</varname></link>.
      It's highly recommended that the said physical replication slot is named in
-     <link linkend="guc-standby-slot-names"><varname>standby_slot_names</varname></link>
+     <link linkend="guc-synchronized-standby-slots"><varname>synchronized_standby_slots</varname></link>
      list on the primary, to prevent the subscriber from consuming changes
      faster than the hot standby. Even when correctly configured, some latency
      is expected when sending changes to logical subscribers due to the waiting
      on slots named in
-     <link linkend="guc-standby-slot-names"><varname>standby_slot_names</varname></link>.
-     When <varname>standby_slot_names</varname> is utilized, the
+     <link linkend="guc-synchronized-standby-slots"><varname>synchronized_standby_slots</varname></link>.
+     When <varname>synchronized_standby_slots</varname> is utilized, the
      primary server will not completely shut down until the corresponding
      standbys, associated with the physical replication slots specified
-     in <varname>standby_slot_names</varname>, have confirmed
+     in <varname>synchronized_standby_slots</varname>, have confirmed
      receiving the WAL up to the latest flushed position on the primary server.
     </para>
 
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 56d3fb5d0e..94896aec28 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -620,8 +620,8 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid)
 	if (remote_slot->confirmed_lsn > latestFlushPtr)
 	{
 		/*
-		 * Can get here only if GUC 'standby_slot_names' on the primary server
-		 * was not configured correctly.
+		 * Can get here only if GUC 'synchronized_standby_slots' on the
+		 * primary server was not configured correctly.
 		 */
 		ereport(AmLogicalSlotSyncWorkerProcess() ? LOG : ERROR,
 				errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index 564cfee127..baf9b89dc4 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -82,11 +82,11 @@ typedef struct ReplicationSlotOnDisk
 } ReplicationSlotOnDisk;
 
 /*
- * Struct for the configuration of standby_slot_names.
+ * Struct for the configuration of synchronized_standby_slots.
  *
  * Note: this must be a flat representation that can be held in a single chunk
  * of guc_malloc'd memory, so that it can be stored as the "extra" data for the
- * standby_slot_names GUC.
+ * synchronized_standby_slots GUC.
  */
 typedef struct
 {
@@ -97,7 +97,7 @@ typedef struct
 	 * slot_names contains 'nslotnames' consecutive null-terminated C strings.
 	 */
 	char		slot_names[FLEXIBLE_ARRAY_MEMBER];
-} StandbySlotNamesConfigData;
+} SyncStandbySlotsConfigData;
 
 /*
  * Lookup table for slot invalidation causes.
@@ -145,14 +145,14 @@ int			max_replication_slots = 10; /* the maximum number of replication
  * This GUC lists streaming replication standby server slot names that
  * logical WAL sender processes will wait for.
  */
-char	   *standby_slot_names;
+char	   *synchronized_standby_slots;
 
-/* This is the parsed and cached configuration for standby_slot_names */
-static StandbySlotNamesConfigData *standby_slot_names_config;
+/* This is the parsed and cached configuration for synchronized_standby_slots */
+static SyncStandbySlotsConfigData *synchronized_standby_slots_config;
 
 /*
  * Oldest LSN that has been confirmed to be flushed to the standbys
- * corresponding to the physical slots specified in the standby_slot_names GUC.
+ * corresponding to the physical slots specified in the synchronized_standby_slots GUC.
  */
 static XLogRecPtr ss_oldest_flush_lsn = InvalidXLogRecPtr;
 
@@ -2412,12 +2412,12 @@ GetSlotInvalidationCause(const char *invalidation_reason)
 }
 
 /*
- * A helper function to validate slots specified in GUC standby_slot_names.
+ * A helper function to validate slots specified in GUC synchronized_standby_slots.
  *
  * The rawname will be parsed, and the result will be saved into *elemlist.
  */
 static bool
-validate_standby_slots(char *rawname, List **elemlist)
+validate_sync_standby_slots(char *rawname, List **elemlist)
 {
 	bool		ok;
 
@@ -2472,17 +2472,17 @@ validate_standby_slots(char *rawname, List **elemlist)
 }
 
 /*
- * GUC check_hook for standby_slot_names
+ * GUC check_hook for synchronized_standby_slots
  */
 bool
-check_standby_slot_names(char **newval, void **extra, GucSource source)
+check_synchronized_standby_slots(char **newval, void **extra, GucSource source)
 {
 	char	   *rawname;
 	char	   *ptr;
 	List	   *elemlist;
 	int			size;
 	bool		ok;
-	StandbySlotNamesConfigData *config;
+	SyncStandbySlotsConfigData *config;
 
 	if ((*newval)[0] == '\0')
 		return true;
@@ -2491,7 +2491,7 @@ check_standby_slot_names(char **newval, void **extra, GucSource source)
 	rawname = pstrdup(*newval);
 
 	/* Now verify if the specified slots exist and have correct type */
-	ok = validate_standby_slots(rawname, &elemlist);
+	ok = validate_sync_standby_slots(rawname, &elemlist);
 
 	if (!ok || elemlist == NIL)
 	{
@@ -2500,15 +2500,15 @@ check_standby_slot_names(char **newval, void **extra, GucSource source)
 		return ok;
 	}
 
-	/* Compute the size required for the StandbySlotNamesConfigData struct */
-	size = offsetof(StandbySlotNamesConfigData, slot_names);
+	/* Compute the size required for the SyncStandbySlotsConfigData struct */
+	size = offsetof(SyncStandbySlotsConfigData, slot_names);
 	foreach_ptr(char, slot_name, elemlist)
 		size += strlen(slot_name) + 1;
 
 	/* GUC extra value must be guc_malloc'd, not palloc'd */
-	config = (StandbySlotNamesConfigData *) guc_malloc(LOG, size);
+	config = (SyncStandbySlotsConfigData *) guc_malloc(LOG, size);
 
-	/* Transform the data into StandbySlotNamesConfigData */
+	/* Transform the data into SyncStandbySlotsConfigData */
 	config->nslotnames = list_length(elemlist);
 
 	ptr = config->slot_names;
@@ -2526,10 +2526,10 @@ check_standby_slot_names(char **newval, void **extra, GucSource source)
 }
 
 /*
- * GUC assign_hook for standby_slot_names
+ * GUC assign_hook for synchronized_standby_slots
  */
 void
-assign_standby_slot_names(const char *newval, void *extra)
+assign_synchronized_standby_slots(const char *newval, void *extra)
 {
 	/*
 	 * The standby slots may have changed, so we must recompute the oldest
@@ -2537,19 +2537,19 @@ assign_standby_slot_names(const char *newval, void *extra)
 	 */
 	ss_oldest_flush_lsn = InvalidXLogRecPtr;
 
-	standby_slot_names_config = (StandbySlotNamesConfigData *) extra;
+	synchronized_standby_slots_config = (SyncStandbySlotsConfigData *) extra;
 }
 
 /*
- * Check if the passed slot_name is specified in the standby_slot_names GUC.
+ * Check if the passed slot_name is specified in the synchronized_standby_slots GUC.
  */
 bool
-SlotExistsInStandbySlotNames(const char *slot_name)
+SlotExistsInSyncStandbySlots(const char *slot_name)
 {
 	const char *standby_slot_name;
 
-	/* Return false if there is no value in standby_slot_names */
-	if (standby_slot_names_config == NULL)
+	/* Return false if there is no value in synchronized_standby_slots */
+	if (synchronized_standby_slots_config == NULL)
 		return false;
 
 	/*
@@ -2557,8 +2557,8 @@ SlotExistsInStandbySlotNames(const char *slot_name)
 	 * shouldn't hurt but if that turns out not to be true then we can cache
 	 * this information for each WalSender as well.
 	 */
-	standby_slot_name = standby_slot_names_config->slot_names;
-	for (int i = 0; i < standby_slot_names_config->nslotnames; i++)
+	standby_slot_name = synchronized_standby_slots_config->slot_names;
+	for (int i = 0; i < synchronized_standby_slots_config->nslotnames; i++)
 	{
 		if (strcmp(standby_slot_name, slot_name) == 0)
 			return true;
@@ -2570,7 +2570,7 @@ SlotExistsInStandbySlotNames(const char *slot_name)
 }
 
 /*
- * Return true if the slots specified in standby_slot_names have caught up to
+ * Return true if the slots specified in synchronized_standby_slots have caught up to
  * the given WAL location, false otherwise.
  *
  * The elevel parameter specifies the error level used for logging messages
@@ -2585,9 +2585,9 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 
 	/*
 	 * Don't need to wait for the standbys to catch up if there is no value in
-	 * standby_slot_names.
+	 * synchronized_standby_slots.
 	 */
-	if (standby_slot_names_config == NULL)
+	if (synchronized_standby_slots_config == NULL)
 		return true;
 
 	/*
@@ -2611,8 +2611,8 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 	 */
 	LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
-	name = standby_slot_names_config->slot_names;
-	for (int i = 0; i < standby_slot_names_config->nslotnames; i++)
+	name = synchronized_standby_slots_config->slot_names;
+	for (int i = 0; i < synchronized_standby_slots_config->nslotnames; i++)
 	{
 		XLogRecPtr	restart_lsn;
 		bool		invalidated;
@@ -2624,43 +2624,44 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 		if (!slot)
 		{
 			/*
-			 * If a slot name provided in standby_slot_names does not exist,
-			 * report a message and exit the loop. A user can specify a slot
-			 * name that does not exist just before the server startup. The
-			 * GUC check_hook(validate_standby_slots) cannot validate such a
-			 * slot during startup as the ReplicationSlotCtl shared memory is
-			 * not initialized at that time. It is also possible for a user to
-			 * drop the slot in standby_slot_names afterwards.
+			 * If a slot name provided in synchronized_standby_slots does not
+			 * exist, report a message and exit the loop. A user can specify a
+			 * slot name that does not exist just before the server startup.
+			 * The GUC check_hook(validate_sync_standby_slots) cannot validate
+			 * such a slot during startup as the ReplicationSlotCtl shared
+			 * memory is not initialized at that time. It is also possible for
+			 * a user to drop the slot in synchronized_standby_slots
+			 * afterwards.
 			 */
 			ereport(elevel,
 					errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 					errmsg("replication slot \"%s\" specified in parameter %s does not exist",
-						   name, "standby_slot_names"),
+						   name, "synchronized_standby_slots"),
 					errdetail("Logical replication is waiting on the standby associated with \"%s\".",
 							  name),
 					errhint("Consider creating the slot \"%s\" or amend parameter %s.",
-							name, "standby_slot_names"));
+							name, "synchronized_standby_slots"));
 			break;
 		}
 
 		if (SlotIsLogical(slot))
 		{
 			/*
-			 * If a logical slot name is provided in standby_slot_names,
-			 * report a message and exit the loop. Similar to the non-existent
-			 * case, a user can specify a logical slot name in
-			 * standby_slot_names before the server startup, or drop an
-			 * existing physical slot and recreate a logical slot with the
-			 * same name.
+			 * If a logical slot name is provided in
+			 * synchronized_standby_slots, report a message and exit the loop.
+			 * Similar to the non-existent case, a user can specify a logical
+			 * slot name in synchronized_standby_slots before the server
+			 * startup, or drop an existing physical slot and recreate a
+			 * logical slot with the same name.
 			 */
 			ereport(elevel,
 					errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 					errmsg("cannot have logical replication slot \"%s\" in parameter %s",
-						   name, "standby_slot_names"),
+						   name, "synchronized_standby_slots"),
 					errdetail("Logical replication is waiting for correction on \"%s\".",
 							  name),
 					errhint("Consider removing logical slot \"%s\" from parameter %s.",
-							name, "standby_slot_names"));
+							name, "synchronized_standby_slots"));
 			break;
 		}
 
@@ -2676,11 +2677,11 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 			ereport(elevel,
 					errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 					errmsg("physical slot \"%s\" specified in parameter %s has been invalidated",
-						   name, "standby_slot_names"),
+						   name, "synchronized_standby_slots"),
 					errdetail("Logical replication is waiting on the standby associated with \"%s\".",
 							  name),
 					errhint("Consider dropping and recreating the slot \"%s\" or amend parameter %s.",
-							name, "standby_slot_names"));
+							name, "synchronized_standby_slots"));
 			break;
 		}
 
@@ -2691,11 +2692,11 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 				ereport(elevel,
 						errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
 						errmsg("replication slot \"%s\" specified in parameter %s does not have active_pid",
-							   name, "standby_slot_names"),
+							   name, "synchronized_standby_slots"),
 						errdetail("Logical replication is waiting on the standby associated with \"%s\".",
 								  name),
 						errhint("Consider starting standby associated with \"%s\" or amend parameter %s.",
-								name, "standby_slot_names"));
+								name, "synchronized_standby_slots"));
 
 			/* Continue if the current slot hasn't caught up. */
 			break;
@@ -2718,7 +2719,7 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
 	 * Return false if not all the standbys have caught up to the specified
 	 * WAL location.
 	 */
-	if (caught_up_slot_num != standby_slot_names_config->nslotnames)
+	if (caught_up_slot_num != synchronized_standby_slots_config->nslotnames)
 		return false;
 
 	/* The ss_oldest_flush_lsn must not retreat. */
@@ -2734,7 +2735,7 @@ StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel)
  * Wait for physical standbys to confirm receiving the given lsn.
  *
  * Used by logical decoding SQL functions. It waits for physical standbys
- * corresponding to the physical slots specified in the standby_slot_names GUC.
+ * corresponding to the physical slots specified in the synchronized_standby_slots GUC.
  */
 void
 WaitForStandbyConfirmation(XLogRecPtr wait_for_lsn)
@@ -2742,9 +2743,9 @@ WaitForStandbyConfirmation(XLogRecPtr wait_for_lsn)
 	/*
 	 * Don't need to wait for the standby to catch up if the current acquired
 	 * slot is not a logical failover slot, or there is no value in
-	 * standby_slot_names.
+	 * synchronized_standby_slots.
 	 */
-	if (!MyReplicationSlot->data.failover || !standby_slot_names_config)
+	if (!MyReplicationSlot->data.failover || !synchronized_standby_slots_config)
 		return;
 
 	ConditionVariablePrepareToSleep(&WalSndCtl->wal_confirm_rcv_cv);
@@ -2764,9 +2765,9 @@ WaitForStandbyConfirmation(XLogRecPtr wait_for_lsn)
 			break;
 
 		/*
-		 * Wait for the slots in the standby_slot_names to catch up, but use a
-		 * timeout (1s) so we can also check if the standby_slot_names has
-		 * been changed.
+		 * Wait for the slots in the synchronized_standby_slots to catch up,
+		 * but use a timeout (1s) so we can also check if the
+		 * synchronized_standby_slots has been changed.
 		 */
 		ConditionVariableTimedSleep(&WalSndCtl->wal_confirm_rcv_cv, 1000,
 									WAIT_EVENT_WAIT_FOR_STANDBY_CONFIRMATION);
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index c623b07cf0..59d1dfc7e2 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1727,7 +1727,7 @@ WalSndUpdateProgress(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId
 
 /*
  * Wake up the logical walsender processes with logical failover slots if the
- * currently acquired physical slot is specified in standby_slot_names GUC.
+ * currently acquired physical slot is specified in synchronized_standby_slots GUC.
  */
 void
 PhysicalWakeupLogicalWalSnd(void)
@@ -1742,7 +1742,7 @@ PhysicalWakeupLogicalWalSnd(void)
 	if (RecoveryInProgress())
 		return;
 
-	if (SlotExistsInStandbySlotNames(NameStr(MyReplicationSlot->data.name)))
+	if (SlotExistsInSyncStandbySlots(NameStr(MyReplicationSlot->data.name)))
 		ConditionVariableBroadcast(&WalSndCtl->wal_confirm_rcv_cv);
 }
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 46c258be28..6f4188599b 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -4692,7 +4692,7 @@ struct config_string ConfigureNamesString[] =
 	},
 
 	{
-		{"standby_slot_names", PGC_SIGHUP, REPLICATION_PRIMARY,
+		{"synchronized_standby_slots", PGC_SIGHUP, REPLICATION_PRIMARY,
 			gettext_noop("Lists streaming replication standby server slot "
 						 "names that logical WAL sender processes will wait for."),
 			gettext_noop("Logical WAL sender processes will send decoded "
@@ -4700,9 +4700,9 @@ struct config_string ConfigureNamesString[] =
 						 "replication slots confirm receiving WAL."),
 			GUC_LIST_INPUT
 		},
-		&standby_slot_names,
+		&synchronized_standby_slots,
 		"",
-		check_standby_slot_names, assign_standby_slot_names, NULL
+		check_synchronized_standby_slots, assign_synchronized_standby_slots, NULL
 	},
 
 	/* End-of-list marker */
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index e0567de219..9ec9f97e92 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -344,8 +344,8 @@
 				# method to choose sync standbys, number of sync standbys,
 				# and comma-separated list of application_name
 				# from standby(s); '*' = all
-#standby_slot_names = ''	# streaming replication standby server slot names that
-				# logical walsender processes will wait for
+#synchronized_standby_slots = ''	# streaming replication standby server slot
+				# names that logical walsender processes will wait for
 
 # - Standby Servers -
 
diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h
index 1bc80960ef..c9675ee87c 100644
--- a/src/include/replication/slot.h
+++ b/src/include/replication/slot.h
@@ -229,7 +229,7 @@ extern PGDLLIMPORT ReplicationSlot *MyReplicationSlot;
 
 /* GUCs */
 extern PGDLLIMPORT int max_replication_slots;
-extern PGDLLIMPORT char *standby_slot_names;
+extern PGDLLIMPORT char *synchronized_standby_slots;
 
 /* shmem initialization functions */
 extern Size ReplicationSlotsShmemSize(void);
@@ -278,7 +278,7 @@ extern void CheckSlotPermissions(void);
 extern ReplicationSlotInvalidationCause
 			GetSlotInvalidationCause(const char *invalidation_reason);
 
-extern bool SlotExistsInStandbySlotNames(const char *slot_name);
+extern bool SlotExistsInSyncStandbySlots(const char *slot_name);
 extern bool StandbySlotsHaveCaughtup(XLogRecPtr wait_for_lsn, int elevel);
 extern void WaitForStandbyConfirmation(XLogRecPtr wait_for_lsn);
 
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 109924ffcd..cf32ac2488 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -115,8 +115,8 @@ typedef struct
 
 	/*
 	 * Used by physical walsenders holding slots specified in
-	 * standby_slot_names to wake up logical walsenders holding logical
-	 * failover slots when a walreceiver confirms the receipt of LSN.
+	 * synchronized_standby_slots to wake up logical walsenders holding
+	 * logical failover slots when a walreceiver confirms the receipt of LSN.
 	 */
 	ConditionVariable wal_confirm_rcv_cv;
 
diff --git a/src/include/utils/guc_hooks.h b/src/include/utils/guc_hooks.h
index d64dc5fcdb..070d3f2a1a 100644
--- a/src/include/utils/guc_hooks.h
+++ b/src/include/utils/guc_hooks.h
@@ -174,8 +174,8 @@ extern bool check_wal_consistency_checking(char **newval, void **extra,
 extern void assign_wal_consistency_checking(const char *newval, void *extra);
 extern bool check_wal_segment_size(int *newval, void **extra, GucSource source);
 extern void assign_wal_sync_method(int new_wal_sync_method, void *extra);
-extern bool check_standby_slot_names(char **newval, void **extra,
-									 GucSource source);
-extern void assign_standby_slot_names(const char *newval, void *extra);
+extern bool check_synchronized_standby_slots(char **newval, void **extra,
+											 GucSource source);
+extern void assign_synchronized_standby_slots(const char *newval, void *extra);
 
 #endif							/* GUC_HOOKS_H */
diff --git a/src/test/recovery/t/040_standby_failover_slots_sync.pl b/src/test/recovery/t/040_standby_failover_slots_sync.pl
index 3b6dddba71..2c51cfc3c8 100644
--- a/src/test/recovery/t/040_standby_failover_slots_sync.pl
+++ b/src/test/recovery/t/040_standby_failover_slots_sync.pl
@@ -598,7 +598,7 @@ ok( $standby1->poll_query_until(
 #				| ----> subscriber1 (failover = true, slot_name = lsub1_slot)
 #				| ----> subscriber2 (failover = false, slot_name = lsub2_slot)
 #
-# standby_slot_names = 'sb1_slot'
+# synchronized_standby_slots = 'sb1_slot'
 #
 # The setup is configured in such a way that the logical slot of subscriber1 is
 # enabled for failover, and thus the subscriber1 will wait for the physical
@@ -629,7 +629,7 @@ $primary->wait_for_replay_catchup($standby2);
 # from getting ahead of the specified physical replication slot (sb1_slot).
 $primary->append_conf(
 	'postgresql.conf', qq(
-standby_slot_names = 'sb1_slot'
+synchronized_standby_slots = 'sb1_slot'
 ));
 $primary->reload;
 
@@ -678,11 +678,11 @@ is($result, 't', "subscriber2 gets data from primary");
 # Wait until the primary server logs a warning indicating that it is waiting
 # for the sb1_slot to catch up.
 $primary->wait_for_log(
-	qr/replication slot \"sb1_slot\" specified in parameter standby_slot_names does not have active_pid/,
+	qr/replication slot \"sb1_slot\" specified in parameter synchronized_standby_slots does not have active_pid/,
 	$offset);
 
 # The regress_mysub1 was enabled for failover so it doesn't get the data from
-# primary and keeps waiting for the standby specified in standby_slot_names
+# primary and keeps waiting for the standby specified in synchronized_standby_slots
 # (sb1_slot aka standby1).
 $result =
   $subscriber1->safe_psql('postgres',
@@ -691,7 +691,7 @@ is($result, 't',
 	"subscriber1 doesn't get data from primary until standby1 acknowledges changes"
 );
 
-# Start the standby specified in standby_slot_names (sb1_slot aka standby1) and
+# Start the standby specified in synchronized_standby_slots (sb1_slot aka standby1) and
 # wait for it to catch up with the primary.
 $standby1->start;
 $primary->wait_for_replay_catchup($standby1);
@@ -699,7 +699,7 @@ $result = $standby1->safe_psql('postgres',
 	"SELECT count(*) = $primary_row_count FROM tab_int;");
 is($result, 't', "standby1 gets data from primary");
 
-# Now that the standby specified in standby_slot_names is up and running, the
+# Now that the standby specified in synchronized_standby_slots is up and running, the
 # primary can send the decoded changes to the subscription enabled for failover
 # (i.e. regress_mysub1). While the standby was down, regress_mysub1 didn't
 # receive any data from the primary. i.e. the primary didn't allow it to go
@@ -713,13 +713,13 @@ is($result, 't',
 ##################################################
 # Verify that when using pg_logical_slot_get_changes to consume changes from a
 # logical failover slot, it will also wait for the slots specified in
-# standby_slot_names to catch up.
+# synchronized_standby_slots to catch up.
 ##################################################
 
 # Stop the standby associated with the specified physical replication slot so
 # that the logical replication slot won't receive changes until the standby
 # slot's restart_lsn is advanced or the slot is removed from the
-# standby_slot_names list.
+# synchronized_standby_slots list.
 $primary->safe_psql('postgres', "TRUNCATE tab_int;");
 $primary->wait_for_catchup('regress_mysub1');
 $standby1->stop;
@@ -757,15 +757,15 @@ $back_q->query_until(
 # Wait until the primary server logs a warning indicating that it is waiting
 # for the sb1_slot to catch up.
 $primary->wait_for_log(
-	qr/replication slot \"sb1_slot\" specified in parameter standby_slot_names does not have active_pid/,
+	qr/replication slot \"sb1_slot\" specified in parameter synchronized_standby_slots does not have active_pid/,
 	$offset);
 
-# Remove the standby from the standby_slot_names list and reload the
+# Remove the standby from the synchronized_standby_slots list and reload the
 # configuration.
-$primary->adjust_conf('postgresql.conf', 'standby_slot_names', "''");
+$primary->adjust_conf('postgresql.conf', 'synchronized_standby_slots', "''");
 $primary->reload;
 
-# Since there are no slots in standby_slot_names, the function
+# Since there are no slots in synchronized_standby_slots, the function
 # pg_logical_slot_get_changes should now return, and the session can be
 # stopped.
 $back_q->quit;
@@ -773,9 +773,10 @@ $back_q->quit;
 $primary->safe_psql('postgres',
 	"SELECT pg_drop_replication_slot('test_slot');");
 
-# Add the physical slot (sb1_slot) back to the standby_slot_names for further
+# Add the physical slot (sb1_slot) back to the synchronized_standby_slots for further
 # tests.
-$primary->adjust_conf('postgresql.conf', 'standby_slot_names', "'sb1_slot'");
+$primary->adjust_conf('postgresql.conf', 'synchronized_standby_slots',
+	"'sb1_slot'");
 $primary->reload;
 
 # Enable the regress_mysub1 for further tests
@@ -784,7 +785,7 @@ $subscriber1->safe_psql('postgres',
 
 ##################################################
 # Test that logical replication will wait for the user-created inactive
-# physical slot to catch up until we remove the slot from standby_slot_names.
+# physical slot to catch up until we remove the slot from synchronized_standby_slots.
 ##################################################
 
 $offset = -s $primary->logfile;
@@ -797,33 +798,34 @@ $primary->safe_psql('postgres',
 # Wait until the primary server logs a warning indicating that it is waiting
 # for the sb1_slot to catch up.
 $primary->wait_for_log(
-	qr/replication slot \"sb1_slot\" specified in parameter standby_slot_names does not have active_pid/,
+	qr/replication slot \"sb1_slot\" specified in parameter synchronized_standby_slots does not have active_pid/,
 	$offset);
 
 # The regress_mysub1 doesn't get the data from primary because the specified
-# standby slot (sb1_slot) in standby_slot_names is inactive.
+# standby slot (sb1_slot) in synchronized_standby_slots is inactive.
 $result =
   $subscriber1->safe_psql('postgres', "SELECT count(*) = 0 FROM tab_int;");
 is($result, 't',
 	"subscriber1 doesn't get data as the sb1_slot doesn't catch up");
 
-# Remove the standby from the standby_slot_names list and reload the
+# Remove the standby from the synchronized_standby_slots list and reload the
 # configuration.
-$primary->adjust_conf('postgresql.conf', 'standby_slot_names', "''");
+$primary->adjust_conf('postgresql.conf', 'synchronized_standby_slots', "''");
 $primary->reload;
 
-# Since there are no slots in standby_slot_names, the primary server should now
+# Since there are no slots in synchronized_standby_slots, the primary server should now
 # send the decoded changes to the subscription.
 $primary->wait_for_catchup('regress_mysub1');
 $result = $subscriber1->safe_psql('postgres',
 	"SELECT count(*) = $primary_row_count FROM tab_int;");
 is($result, 't',
-	"subscriber1 gets data from primary after standby1 is removed from the standby_slot_names list"
+	"subscriber1 gets data from primary after standby1 is removed from the synchronized_standby_slots list"
 );
 
-# Add the physical slot (sb1_slot) back to the standby_slot_names for further
+# Add the physical slot (sb1_slot) back to the synchronized_standby_slots for further
 # tests.
-$primary->adjust_conf('postgresql.conf', 'standby_slot_names', "'sb1_slot'");
+$primary->adjust_conf('postgresql.conf', 'synchronized_standby_slots',
+	"'sb1_slot'");
 $primary->reload;
 
 ##################################################
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 61ad417cde..a8b97f0122 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2717,7 +2717,6 @@ SplitPoint
 SplitTextOutputData
 SplitVar
 StackElem
-StandbySlotNamesConfigData
 StartDataPtrType
 StartLOPtrType
 StartLOsPtrType
@@ -2782,6 +2781,7 @@ SyncRepConfigData
 SyncRepStandbyData
 SyncRequestHandler
 SyncRequestType
+SyncStandbySlotsConfigData
 SyncingTablesState
 SysFKRelationship
 SysScanDesc
-- 
2.30.0.windows.2

