Rename logical_replication_mode to debug_logical_replication_streaming

The logical_replication_mode GUC is intended for testing and debugging
purposes, but its current name may be misleading and encourage users to make
unnecessary changes.

To avoid confusion, renaming the GUC to a less misleading name
debug_logical_replication_streaming that casual users are less likely to mistakenly
assume needs to be modified in a regular logical replication setup.

Author: Hou Zhijie <houzj.fnst@cn.fujitsu.com>
Reviewed-by: Peter Smith <smithpb2250@gmail.com>
Discussion: https://www.postgresql.org/message-id/flat/d672d774-c44b-6fec-f993-793e744f169a%40eisentraut.org

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index a5cb15febaae1344f93ee7a1080618d872e07d31..bc140c35667a2d4174233f8aacd1695082c91485 100644 (file)
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11743,10 +11743,10 @@ LOG:  CleanUpLock: deleting: lock(0xb7acd844) id(24688,24696,0,0,0,1)
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-logical-replication-mode" xreflabel="logical_replication_mode">
-      <term><varname>logical_replication_mode</varname> (<type>enum</type>)
+     <varlistentry id="guc-debug-logical-replication-streaming" xreflabel="debug_logical_replication_streaming">
+      <term><varname>debug_logical_replication_streaming</varname> (<type>enum</type>)
       <indexterm>
-       <primary><varname>logical_replication_mode</varname> configuration parameter</primary>
+       <primary><varname>debug_logical_replication_streaming</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
@@ -11755,12 +11755,12 @@ LOG:  CleanUpLock: deleting: lock(0xb7acd844) id(24688,24696,0,0,0,1)
         <literal>immediate</literal>. The default is <literal>buffered</literal>.
         This parameter is intended to be used to test logical decoding and
         replication of large transactions.  The effect of
-        <varname>logical_replication_mode</varname> is different for the
+        <varname>debug_logical_replication_streaming</varname> is different for the
         publisher and subscriber:
        </para>
 
        <para>
-        On the publisher side, <varname>logical_replication_mode</varname>
+        On the publisher side, <varname>debug_logical_replication_streaming</varname>
         allows streaming or serializing changes immediately in logical decoding.
         When set to <literal>immediate</literal>, stream each change if the
         <link linkend="sql-createsubscription-with-streaming"><literal>streaming</literal></link>
@@ -11773,7 +11773,7 @@ LOG:  CleanUpLock: deleting: lock(0xb7acd844) id(24688,24696,0,0,0,1)
 
        <para>
         On the subscriber side, if the <literal>streaming</literal> option is set to
-        <literal>parallel</literal>, <varname>logical_replication_mode</varname>
+        <literal>parallel</literal>, <varname>debug_logical_replication_streaming</varname>
         can be used to direct the leader apply worker to send changes to the
         shared memory queue or to serialize all changes to the file.  When set to
         <literal>buffered</literal>, the leader sends changes to parallel apply

diff --git a/doc/src/sgml/release-16.sgml b/doc/src/sgml/release-16.sgml
index 21843618ee7a3c65825298944b3b8d531b4b2ac1..2eb172eaa63efc4270f05de9dea62df606e5eb81 100644 (file)
--- a/doc/src/sgml/release-16.sgml
+++ b/doc/src/sgml/release-16.sgml
@@ -1709,7 +1709,7 @@ Author: Amit Kapila <akapila@postgresql.org>
 
       <para>
        The variable is <link
-       linkend="guc-logical-replication-mode"><varname>logical_replication_mode</varname></link>.
+       linkend="guc-debug-logical-replication-streaming"><varname>debug_logical_replication_streaming</varname></link>.
       </para>
      </listitem>
 

diff --git a/src/backend/replication/logical/applyparallelworker.c b/src/backend/replication/logical/applyparallelworker.c
index 6fb96148f4ad55155631db338116d36acc9e8a7c..a24709ec7a5f4d52bf7861fb3f3eb1221c9f9722 100644 (file)
--- a/src/backend/replication/logical/applyparallelworker.c
+++ b/src/backend/replication/logical/applyparallelworker.c
@@ -1159,7 +1159,7 @@ pa_send_data(ParallelApplyWorkerInfo *winfo, Size nbytes, const void *data)
         * We don't try to send data to parallel worker for 'immediate' mode. This
         * is primarily used for testing purposes.
         */
-       if (unlikely(logical_replication_mode == LOGICAL_REP_MODE_IMMEDIATE))
+       if (unlikely(debug_logical_replication_streaming == DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE))
                return false;
 
 /*

diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index 87a4d2a24b7ac2259cd264b39c0070639c440d51..0dab0bb64e8d6c668abf44166118e523f3270baa 100644 (file)
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -210,7 +210,7 @@ int                 logical_decoding_work_mem;
 static const Size max_changes_in_memory = 4096; /* XXX for restore only */
 
 /* GUC variable */
-int                    logical_replication_mode = LOGICAL_REP_MODE_BUFFERED;
+int                    debug_logical_replication_streaming = DEBUG_LOGICAL_REP_STREAMING_BUFFERED;
 
 /* ---------------------------------------
  * primary reorderbuffer support routines
@@ -3566,8 +3566,8 @@ ReorderBufferLargestStreamableTopTXN(ReorderBuffer *rb)
  * pick the largest (sub)transaction at-a-time to evict and spill its changes to
  * disk or send to the output plugin until we reach under the memory limit.
  *
- * If logical_replication_mode is set to "immediate", stream or serialize the
- * changes immediately.
+ * If debug_logical_replication_streaming is set to "immediate", stream or
+ * serialize the changes immediately.
  *
  * XXX At this point we select the transactions until we reach under the memory
  * limit, but we might also adapt a more elaborate eviction strategy - for example
@@ -3580,25 +3580,25 @@ ReorderBufferCheckMemoryLimit(ReorderBuffer *rb)
        ReorderBufferTXN *txn;
 
        /*
-        * Bail out if logical_replication_mode is buffered and we haven't
-        * exceeded the memory limit.
+        * Bail out if debug_logical_replication_streaming is buffered and we
+        * haven't exceeded the memory limit.
         */
-       if (logical_replication_mode == LOGICAL_REP_MODE_BUFFERED &&
+       if (debug_logical_replication_streaming == DEBUG_LOGICAL_REP_STREAMING_BUFFERED &&
                rb->size < logical_decoding_work_mem * 1024L)
                return;
 
        /*
-        * If logical_replication_mode is immediate, loop until there's no change.
-        * Otherwise, loop until we reach under the memory limit. One might think
-        * that just by evicting the largest (sub)transaction we will come under
-        * the memory limit based on assumption that the selected transaction is
-        * at least as large as the most recent change (which caused us to go over
-        * the memory limit). However, that is not true because a user can reduce
-        * the logical_decoding_work_mem to a smaller value before the most recent
-        * change.
+        * If debug_logical_replication_streaming is immediate, loop until there's
+        * no change. Otherwise, loop until we reach under the memory limit. One
+        * might think that just by evicting the largest (sub)transaction we will
+        * come under the memory limit based on assumption that the selected
+        * transaction is at least as large as the most recent change (which
+        * caused us to go over the memory limit). However, that is not true
+        * because a user can reduce the logical_decoding_work_mem to a smaller
+        * value before the most recent change.
         */
        while (rb->size >= logical_decoding_work_mem * 1024L ||
-                  (logical_replication_mode == LOGICAL_REP_MODE_IMMEDIATE &&
+                  (debug_logical_replication_streaming == DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE &&
                        rb->size > 0))
        {
                /*

diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 45b93fe0f98b5d0db5abe28dd681cba6db548ee7..0f4ad24d8ecb08890d41cf1fb80a5c2940ab4f0f 100644 (file)
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -413,9 +413,9 @@ static const struct config_enum_entry ssl_protocol_versions_info[] = {
        {NULL, 0, false}
 };
 
-static const struct config_enum_entry logical_replication_mode_options[] = {
-       {"buffered", LOGICAL_REP_MODE_BUFFERED, false},
-       {"immediate", LOGICAL_REP_MODE_IMMEDIATE, false},
+static const struct config_enum_entry debug_logical_replication_streaming_options[] = {
+       {"buffered", DEBUG_LOGICAL_REP_STREAMING_BUFFERED, false},
+       {"immediate", DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE, false},
        {NULL, 0, false}
 };
 
@@ -4956,15 +4956,15 @@ struct config_enum ConfigureNamesEnum[] =
        },
 
        {
-               {"logical_replication_mode", PGC_USERSET, DEVELOPER_OPTIONS,
-                       gettext_noop("Controls when to replicate or apply each change."),
+               {"debug_logical_replication_streaming", PGC_USERSET, DEVELOPER_OPTIONS,
+                       gettext_noop("Forces immediate streaming or serialization of changes in large transactions."),
                        gettext_noop("On the publisher, it allows streaming or serializing each change in logical decoding. "
                                                 "On the subscriber, it allows serialization of all changes to files and notifies the "
                                                 "parallel apply workers to read and apply them at the end of the transaction."),
                        GUC_NOT_IN_SAMPLE
                },
-               &logical_replication_mode,
-               LOGICAL_REP_MODE_BUFFERED, logical_replication_mode_options,
+               &debug_logical_replication_streaming,
+               DEBUG_LOGICAL_REP_STREAMING_BUFFERED, debug_logical_replication_streaming_options,
                NULL, NULL, NULL
        },
 

diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h
index 1b9db22acbd7fd74c251d2bb505147ea204505f1..3cb03168de246ce32ebd78068a30a36d6cd397d4 100644 (file)
--- a/src/include/replication/reorderbuffer.h
+++ b/src/include/replication/reorderbuffer.h
@@ -19,14 +19,14 @@
 
 /* GUC variables */
 extern PGDLLIMPORT int logical_decoding_work_mem;
-extern PGDLLIMPORT int logical_replication_mode;
+extern PGDLLIMPORT int debug_logical_replication_streaming;
 
-/* possible values for logical_replication_mode */
+/* possible values for debug_logical_replication_streaming */
 typedef enum
 {
-       LOGICAL_REP_MODE_BUFFERED,
-       LOGICAL_REP_MODE_IMMEDIATE
-}                      LogicalRepMode;
+       DEBUG_LOGICAL_REP_STREAMING_BUFFERED,
+       DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE
+}                      DebugLogicalRepStreamingMode;
 
 /* an individual tuple, stored in one chunk of memory */
 typedef struct ReorderBufferTupleBuf

diff --git a/src/test/subscription/t/015_stream.pl b/src/test/subscription/t/015_stream.pl
index 5c00711ef2d6ec70547bb373fb64bf9ce811b470..be70b869466279cb032f887d8da4ac598999aea8 100644 (file)
--- a/src/test/subscription/t/015_stream.pl
+++ b/src/test/subscription/t/015_stream.pl
@@ -295,7 +295,7 @@ is($result, qq(10000), 'data replicated to subscriber after dropping index');
 # Test serializing changes to files and notify the parallel apply worker to
 # apply them at the end of the transaction.
 $node_subscriber->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 # Reset the log_min_messages to default.
 $node_subscriber->append_conf('postgresql.conf',
        "log_min_messages = warning");

diff --git a/src/test/subscription/t/016_stream_subxact.pl b/src/test/subscription/t/016_stream_subxact.pl
index d830f26e06f4b72ef112e3881b5e44c1620fd3cc..a962cd844b19efc16afc922616d6f78afb28bd97 100644 (file)
--- a/src/test/subscription/t/016_stream_subxact.pl
+++ b/src/test/subscription/t/016_stream_subxact.pl
@@ -79,7 +79,7 @@ sub test_streaming
 my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
 $node_publisher->init(allows_streaming => 'logical');
 $node_publisher->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 $node_publisher->start;
 
 # Create subscriber node

diff --git a/src/test/subscription/t/018_stream_subxact_abort.pl b/src/test/subscription/t/018_stream_subxact_abort.pl
index 91d19ae672ad7e2f44b3191124b24f799b2dff9e..91730d9b7c394da1f357c1d8347a46dca4fbd601 100644 (file)
--- a/src/test/subscription/t/018_stream_subxact_abort.pl
+++ b/src/test/subscription/t/018_stream_subxact_abort.pl
@@ -130,7 +130,7 @@ sub test_streaming
 my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
 $node_publisher->init(allows_streaming => 'logical');
 $node_publisher->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 $node_publisher->start;
 
 # Create subscriber node
@@ -203,7 +203,7 @@ test_streaming($node_publisher, $node_subscriber, $appname, 1);
 # Test serializing changes to files and notify the parallel apply worker to
 # apply them at the end of the transaction.
 $node_subscriber->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 # Reset the log_min_messages to default.
 $node_subscriber->append_conf('postgresql.conf',
        "log_min_messages = warning");

diff --git a/src/test/subscription/t/019_stream_subxact_ddl_abort.pl b/src/test/subscription/t/019_stream_subxact_ddl_abort.pl
index d0e556c8b8307f03ad8ea87ad407f9de5868bc7c..420b9a7b516e535045c94c70c3f14f63b47179ef 100644 (file)
--- a/src/test/subscription/t/019_stream_subxact_ddl_abort.pl
+++ b/src/test/subscription/t/019_stream_subxact_ddl_abort.pl
@@ -16,7 +16,7 @@ use Test::More;
 my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
 $node_publisher->init(allows_streaming => 'logical');
 $node_publisher->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 $node_publisher->start;
 
 # Create subscriber node

diff --git a/src/test/subscription/t/023_twophase_stream.pl b/src/test/subscription/t/023_twophase_stream.pl
index fdcc4b359d2aee08bb964f13fb776afb98f29bc3..0303807846e48b7a69fca9da37f47d8a1be992da 100644 (file)
--- a/src/test/subscription/t/023_twophase_stream.pl
+++ b/src/test/subscription/t/023_twophase_stream.pl
@@ -301,7 +301,7 @@ $node_publisher->init(allows_streaming => 'logical');
 $node_publisher->append_conf(
        'postgresql.conf', qq(
 max_prepared_transactions = 10
-logical_replication_mode = immediate
+debug_logical_replication_streaming = immediate
 ));
 $node_publisher->start;
 
@@ -389,7 +389,7 @@ test_streaming($node_publisher, $node_subscriber, $appname, 1);
 # Test serializing changes to files and notify the parallel apply worker to
 # apply them at the end of the transaction.
 $node_subscriber->append_conf('postgresql.conf',
-       'logical_replication_mode = immediate');
+       'debug_logical_replication_streaming = immediate');
 # Reset the log_min_messages to default.
 $node_subscriber->append_conf('postgresql.conf',
        "log_min_messages = warning");