contrib/postgres_fdw/expected/postgres_fdw.out

@@ -9730,18 +9730,20 @@ 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
-   ->  Nested Loop
+   ->  Sort
-         Join Filter: (t1.a = t2.b)
+         Sort Key: t1.a
-         ->  Append
+         ->  Hash Join
-               ->  Foreign Scan on ftprt1_p1 t1_1
+               Hash Cond: (t2.b = t1.a)
-               ->  Foreign Scan on ftprt1_p2 t1_2
-         ->  Materialize
                ->  Append
                      ->  Foreign Scan on ftprt2_p1 t2_1
                      ->  Foreign Scan on ftprt2_p2 t2_2
-(10 rows)
+               ->  Hash
+                     ->  Append
+                           ->  Foreign Scan on ftprt1_p1 t1_1
+                           ->  Foreign Scan on ftprt1_p2 t1_2
+(12 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  
@@ -9777,15 +9779,17 @@ 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                         
------------------------------------------------------
+-----------------------------------------------------------
- GroupAggregate
+ Sort
+   Sort Key: pagg_tab.a
+   ->  HashAggregate
          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
-(7 rows)
+(9 rows)
 
 -- Plan with partitionwise aggregates is enabled
 SET enable_partitionwise_aggregate TO true;
@@ -9820,31 +9824,33 @@ 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                               
---------------------------------------------------------------------------------------------
+------------------------------------------------------------------------
- Merge Append
+ Sort
+   Output: t1.a, (count(((t1.*)::pagg_tab)))
    Sort Key: t1.a
-   ->  GroupAggregate
+   ->  Append
+         ->  HashAggregate
                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 ORDER BY a ASC NULLS LAST
+                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p1
-   ->  GroupAggregate
+         ->  HashAggregate
                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 ORDER BY a ASC NULLS LAST
+                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p2
-   ->  GroupAggregate
+         ->  HashAggregate
                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 ORDER BY a ASC NULLS LAST
+                     Remote SQL: SELECT a, b, c FROM public.pagg_tab_p3
-(23 rows)
+(25 rows)
 
 SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
  a  | count 
@@ -9861,22 +9867,23 @@ 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                            
------------------------------------------------------------
+-----------------------------------------------------------------
- Finalize GroupAggregate
+ Sort
+   Sort Key: pagg_tab.b
+   ->  Finalize HashAggregate
          Group Key: pagg_tab.b
          Filter: (sum(pagg_tab.a) < 700)
-   ->  Merge Append
+         ->  Append
-         Sort Key: pagg_tab.b
+               ->  Partial HashAggregate
-         ->  Partial GroupAggregate
                      Group Key: pagg_tab.b
                      ->  Foreign Scan on fpagg_tab_p1 pagg_tab
-         ->  Partial GroupAggregate
+               ->  Partial HashAggregate
                      Group Key: pagg_tab_1.b
                      ->  Foreign Scan on fpagg_tab_p2 pagg_tab_1
-         ->  Partial GroupAggregate
+               ->  Partial HashAggregate
                      Group Key: pagg_tab_2.b
                      ->  Foreign Scan on fpagg_tab_p3 pagg_tab_2
-(14 rows)
+(15 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.2
+#define DEFAULT_FDW_TUPLE_COST		0.01
 
 /* 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>raise_exception</literal> (<literal>P0001</literal>).
+    <literal>ERRCODE_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,10 +2222,8 @@ psql "dbname=postgres replication=database" -c "IDENTIFY_SYSTEM;"
       </para>
 
       <para>
-       WAL data is sent as a series of CopyData messages;
+       WAL data is sent as a series of CopyData messages.  (This allows
-       see <xref linkend="protocol-message-types"/> and <xref
+       other information to be intermixed; in particular the server can send
-       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,29 +3428,6 @@ 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
@@ -3474,13 +3451,6 @@ 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_mod_since_analyze */
+/* pg_stat_get_mods_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,13 +14,12 @@ $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' AND category <> 'Customized Options'
+       name <> 'config_file'
      ORDER BY 1");
 # Note the lower-case conversion, for consistency.
 my @all_params_array = split("\n", lc($all_params));