Fix 003_check_guc.pl when loading modules with custom GUCs

The test missed that custom GUCs need to be ignored from the list of
parameters that can exist in postgresql.conf.sample.  This caused the
test to fail on a server where such a module is loaded, when using
EXTRA_INSTALL and TEMP_CONFIG, for instance.

Author: Anton A. Melnikov
Discussion: https://postgr.es/m/fc5509ce-5144-4dac-8d13-21793da44fc5@postgrespro.ru
Backpatch-through: 15

contrib/postgres_fdw/expected/postgres_fdw.out

@@ -9730,20 +9730,18 @@ SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE
 EXPLAIN (COSTS OFF)
 SELECT t1.a, t2.b FROM fprt1 t1 INNER JOIN fprt2 t2 ON (t1.a = t2.b) WHERE t1.a % 25 = 0 ORDER BY 1,2 FOR UPDATE OF t1;
                        QUERY PLAN                       
---------------------------------------------------------------
+--------------------------------------------------------
  LockRows
-   ->  Sort
-         Sort Key: t1.a
-         ->  Hash Join
-               Hash Cond: (t2.b = t1.a)
-               ->  Append
-                     ->  Foreign Scan on ftprt2_p1 t2_1
-                     ->  Foreign Scan on ftprt2_p2 t2_2
-               ->  Hash
+   ->  Nested Loop
+         Join Filter: (t1.a = t2.b)
          ->  Append
                ->  Foreign Scan on ftprt1_p1 t1_1
                ->  Foreign Scan on ftprt1_p2 t1_2
-(12 rows)
+         ->  Materialize
+               ->  Append
+                     ->  Foreign Scan on ftprt2_p1 t2_1
+                     ->  Foreign Scan on ftprt2_p2 t2_2
+(10 rows)
 
 SELECT t1.a, t2.b FROM fprt1 t1 INNER JOIN fprt2 t2 ON (t1.a = t2.b) WHERE t1.a % 25 = 0 ORDER BY 1,2 FOR UPDATE OF t1;
   a  |  b  
@@ -9779,17 +9777,15 @@ SET enable_partitionwise_aggregate TO false;
 EXPLAIN (COSTS OFF)
 SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
                      QUERY PLAN                      
------------------------------------------------------------
- Sort
-   Sort Key: pagg_tab.a
-   ->  HashAggregate
+-----------------------------------------------------
+ GroupAggregate
    Group Key: pagg_tab.a
    Filter: (avg(pagg_tab.b) < '22'::numeric)
    ->  Append
          ->  Foreign Scan on fpagg_tab_p1 pagg_tab_1
          ->  Foreign Scan on fpagg_tab_p2 pagg_tab_2
          ->  Foreign Scan on fpagg_tab_p3 pagg_tab_3
-(9 rows)
+(7 rows)
 
 -- Plan with partitionwise aggregates is enabled
 SET enable_partitionwise_aggregate TO true;
@@ -9824,33 +9820,31 @@ SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 O
 EXPLAIN (VERBOSE, COSTS OFF)
 SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
                                          QUERY PLAN                                         
-------------------------------------------------------------------------
- Sort
-   Output: t1.a, (count(((t1.*)::pagg_tab)))
+--------------------------------------------------------------------------------------------
+ Merge Append
    Sort Key: t1.a
-   ->  Append
-         ->  HashAggregate
+   ->  GroupAggregate
          Output: t1.a, count(((t1.*)::pagg_tab))
          Group Key: t1.a
          Filter: (avg(t1.b) < '22'::numeric)
          ->  Foreign Scan on public.fpagg_tab_p1 t1
                Output: t1.a, t1.*, t1.b
-                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p1
-         ->  HashAggregate
+               Remote SQL: SELECT a, b, c FROM public.pagg_tab_p1 ORDER BY a ASC NULLS LAST
+   ->  GroupAggregate
          Output: t1_1.a, count(((t1_1.*)::pagg_tab))
          Group Key: t1_1.a
          Filter: (avg(t1_1.b) < '22'::numeric)
          ->  Foreign Scan on public.fpagg_tab_p2 t1_1
                Output: t1_1.a, t1_1.*, t1_1.b
-                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p2
-         ->  HashAggregate
+               Remote SQL: SELECT a, b, c FROM public.pagg_tab_p2 ORDER BY a ASC NULLS LAST
+   ->  GroupAggregate
          Output: t1_2.a, count(((t1_2.*)::pagg_tab))
          Group Key: t1_2.a
          Filter: (avg(t1_2.b) < '22'::numeric)
          ->  Foreign Scan on public.fpagg_tab_p3 t1_2
                Output: t1_2.a, t1_2.*, t1_2.b
-                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p3
-(25 rows)
+               Remote SQL: SELECT a, b, c FROM public.pagg_tab_p3 ORDER BY a ASC NULLS LAST
+(23 rows)
 
 SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
  a  | count 
@@ -9867,23 +9861,22 @@ SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
 EXPLAIN (COSTS OFF)
 SELECT b, avg(a), max(a), count(*) FROM pagg_tab GROUP BY b HAVING sum(a) < 700 ORDER BY 1;
                         QUERY PLAN                         
------------------------------------------------------------------
- Sort
-   Sort Key: pagg_tab.b
-   ->  Finalize HashAggregate
+-----------------------------------------------------------
+ Finalize GroupAggregate
    Group Key: pagg_tab.b
    Filter: (sum(pagg_tab.a) < 700)
-         ->  Append
-               ->  Partial HashAggregate
+   ->  Merge Append
+         Sort Key: pagg_tab.b
+         ->  Partial GroupAggregate
                Group Key: pagg_tab.b
                ->  Foreign Scan on fpagg_tab_p1 pagg_tab
-               ->  Partial HashAggregate
+         ->  Partial GroupAggregate
                Group Key: pagg_tab_1.b
                ->  Foreign Scan on fpagg_tab_p2 pagg_tab_1
-               ->  Partial HashAggregate
+         ->  Partial GroupAggregate
                Group Key: pagg_tab_2.b
                ->  Foreign Scan on fpagg_tab_p3 pagg_tab_2
-(15 rows)
+(14 rows)
 
 -- ===================================================================
 -- access rights and superuser

contrib/postgres_fdw/postgres_fdw.c

@@ -57,7 +57,7 @@ PG_MODULE_MAGIC;
 #define DEFAULT_FDW_STARTUP_COST	100.0
 
 /* Default CPU cost to process 1 row (above and beyond cpu_tuple_cost). */
-#define DEFAULT_FDW_TUPLE_COST		0.01
+#define DEFAULT_FDW_TUPLE_COST		0.2
 
 /* If no remote estimates, assume a sort costs 20% extra */
 #define DEFAULT_FDW_SORT_MULTIPLIER 1.2

doc/src/sgml/plpgsql.sgml

@@ -3942,7 +3942,7 @@ RAISE unique_violation USING MESSAGE = 'Duplicate user ID: ' || user_id;
    <para>
     If no condition name nor SQLSTATE is specified in a
     <command>RAISE EXCEPTION</command> command, the default is to use
-    <literal>ERRCODE_RAISE_EXCEPTION</literal> (<literal>P0001</literal>).
+    <literal>raise_exception</literal> (<literal>P0001</literal>).
     If no message text is specified, the default is to use the condition
     name or SQLSTATE as message text.
    </para>

doc/src/sgml/protocol.sgml

@@ -2222,8 +2222,10 @@ psql "dbname=postgres replication=database" -c "IDENTIFY_SYSTEM;"
       </para>
 
       <para>
-       WAL data is sent as a series of CopyData messages.  (This allows
-       other information to be intermixed; in particular the server can send
+       WAL data is sent as a series of CopyData messages;
+       see <xref linkend="protocol-message-types"/> and <xref
+       linkend="protocol-message-formats"/> for details.
+       (This allows other information to be intermixed; in particular the server can send
        an ErrorResponse message if it encounters a failure after beginning
        to stream.)  The payload of each CopyData message from server to the
        client contains a message of one of the following formats:

doc/src/sgml/xfunc.sgml

@@ -3428,6 +3428,29 @@ void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
      <filename>contrib/pg_stat_statements/pg_stat_statements.c</filename> in the
      <productname>PostgreSQL</productname> source tree.
     </para>
+    <para>
+     There is another, more flexible method of obtaining LWLocks. First,
+     allocate a <literal>tranche_id</literal> from a shared counter by
+     calling:
+<programlisting>
+int LWLockNewTrancheId(void)
+</programlisting>
+     Next, each individual process using the <literal>tranche_id</literal>
+     should associate it with a <literal>tranche_name</literal> by calling:
+<programlisting>
+void LWLockRegisterTranche(int tranche_id, const char *tranche_name)
+</programlisting>
+     It is also required to call <function>LWLockInitialize</function> once
+     per LWLock, passing the <literal>tranche_id</literal> as argument:
+<programlisting>
+void LWLockInitialize(LWLock *lock, int tranche_id)
+</programlisting>
+     A complete usage example of <function>LWLockNewTrancheId</function>,
+     <function>LWLockInitialize</function> and
+     <function>LWLockRegisterTranche</function> can be found in
+     <filename>contrib/pg_prewarm/autoprewarm.c</filename> in the
+     <productname>PostgreSQL</productname> source tree.
+    </para>
     <para>
      To avoid possible race-conditions, each backend should use the LWLock
      <function>AddinShmemInitLock</function> when connecting to and initializing
@@ -3451,6 +3474,13 @@ if (!ptr)
 }
 </programlisting>
     </para>
+    <para>
+     It is convenient to use <literal>shmem_startup_hook</literal> which allows
+     placing all the code responsible for initializing shared memory in one
+     place. When using <literal>shmem_startup_hook</literal> the extension
+     still needs to acquire <function>AddinShmemInitLock</function> in order to
+     work properly on all the supported platforms.
+    </para>
    </sect2>
 
    <sect2 id="xfunc-addin-wait-events">

src/backend/utils/adt/pgstatfuncs.c

@@ -78,7 +78,7 @@ PG_STAT_GET_RELENTRY_INT64(ins_since_vacuum)
 /* pg_stat_get_live_tuples */
 PG_STAT_GET_RELENTRY_INT64(live_tuples)
 
-/* pg_stat_get_mods_since_analyze */
+/* pg_stat_get_mod_since_analyze */
 PG_STAT_GET_RELENTRY_INT64(mod_since_analyze)
 
 /* pg_stat_get_numscans */

src/test/modules/test_misc/t/003_check_guc.pl

@@ -14,12 +14,13 @@ $node->start;
 # Grab the names of all the parameters that can be listed in the
 # configuration sample file.  config_file is an exception, it is not
 # in postgresql.conf.sample but is part of the lists from guc_tables.c.
+# Custom GUCs loaded by extensions are excluded.
 my $all_params = $node->safe_psql(
 	'postgres',
 	"SELECT name
      FROM pg_settings
    WHERE NOT 'NOT_IN_SAMPLE' = ANY (pg_settings_get_flags(name)) AND
-       name <> 'config_file'
+       name <> 'config_file' AND category <> 'Customized Options'
      ORDER BY 1");
 # Note the lower-case conversion, for consistency.
 my @all_params_array = split("\n", lc($all_params));