Statistics Import and Export

From 9bd1618db9e40caad773334921f0a43d9d63e73a Mon Sep 17 00:00:00 2001
From: coreyhuinker <corey.huinker@gmail.com>
Date: Mon, 30 Oct 2023 16:21:30 -0400
Subject: [PATCH v2 1/4] Additional internal jsonb access functions.

Make JsonbContainerTypeName externally visible.

Add JsonbStringValueToCString.
---
 src/include/utils/jsonb.h          |  4 ++++
 src/backend/utils/adt/jsonb.c      |  2 +-
 src/backend/utils/adt/jsonb_util.c | 15 +++++++++++++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/jsonb.h b/src/include/utils/jsonb.h
index addc9b608e..b3c1e104f2 100644
--- a/src/include/utils/jsonb.h
+++ b/src/include/utils/jsonb.h
@@ -424,6 +424,8 @@ extern char *JsonbToCStringIndent(StringInfo out, JsonbContainer *in,
 								  int estimated_len);
 extern bool JsonbExtractScalar(JsonbContainer *jbc, JsonbValue *res);
 extern const char *JsonbTypeName(JsonbValue *val);
+extern const char *JsonbContainerTypeName(JsonbContainer *jbc);
+
 
 extern Datum jsonb_set_element(Jsonb *jb, Datum *path, int path_len,
 							   JsonbValue *newval);
@@ -436,4 +438,6 @@ extern Datum jsonb_build_object_worker(int nargs, const Datum *args, const bool
 extern Datum jsonb_build_array_worker(int nargs, const Datum *args, const bool *nulls,
 									  const Oid *types, bool absent_on_null);
 
+extern char *JsonbStringValueToCString(JsonbValue *j);
+
 #endif							/* __JSONB_H__ */
diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c
index 6f445f5c2b..0ad4e81d89 100644
--- a/src/backend/utils/adt/jsonb.c
+++ b/src/backend/utils/adt/jsonb.c
@@ -160,7 +160,7 @@ jsonb_from_text(text *js, bool unique_keys)
 /*
  * Get the type name of a jsonb container.
  */
-static const char *
+const char *
 JsonbContainerTypeName(JsonbContainer *jbc)
 {
 	JsonbValue	scalar;
diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 9cc95b773d..ae311b38ba 100644
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -1992,3 +1992,18 @@ uniqueifyJsonbObject(JsonbValue *object, bool unique_keys, bool skip_nulls)
 		}
 	}
 }
+
+/*
+ * Extract a JsonbValue as a cstring.
+ */
+char *JsonbStringValueToCString(JsonbValue *j)
+{
+	char *s;
+
+	Assert(j->type == jbvString);
+	/* make a string that we are sure is null-terminated */
+	s = palloc(j->val.string.len + 1);
+	memcpy(s, j->val.string.val, j->val.string.len);
+	s[j->val.string.len] = '\0';
+	return s;
+}
-- 
2.41.0

From 920d546032a330fe1ec4c8f6a35c48a47ccd08b2 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 31 Oct 2023 02:27:17 -0400
Subject: [PATCH v2 2/4] Add system view pg_statistic_export.

This view is designed to aid in the export (and re-import) of table
statistics and extended statistics, mostly for upgrade/restore
situations.
---
 src/backend/catalog/system_views.sql | 215 +++++++++++++++++++++++++++
 src/test/regress/expected/rules.out  |  71 +++++++++
 doc/src/sgml/system-views.sgml       |   5 +
 3 files changed, 291 insertions(+)

diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index b65f6b5249..11a1037ceb 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -253,6 +253,221 @@ CREATE VIEW pg_stats WITH (security_barrier) AS
 
 REVOKE ALL ON pg_statistic FROM public;
 
+
+
+
+CREATE VIEW pg_statistic_export WITH (security_barrier) AS
+    SELECT
+        n.nspname AS schemaname,
+        r.relname AS relname,
+        current_setting('server_version_num')::integer AS server_version_num,
+        r.reltuples::float4 AS n_tuples,
+        r.relpages::integer AS n_pages,
+        (
+            WITH per_column_stats AS
+            (
+                SELECT
+                    s.stainherit,
+                    a.attname,
+                    jsonb_build_object(
+                        'stanullfrac', s.stanullfrac::text,
+                        'stawidth', s.stawidth::text,
+                        'stadistinct', s.stadistinct::text,
+                        'stakinds',
+                        (
+                            SELECT
+                                jsonb_agg(
+                                    CASE kind.kind
+                                        WHEN 0 THEN 'TRIVIAL'
+                                        WHEN 1 THEN 'MCV'
+                                        WHEN 2 THEN 'HISTOGRAM'
+                                        WHEN 3 THEN 'CORRELATION'
+                                        WHEN 4 THEN 'MCELEM'
+                                        WHEN 5 THEN 'DECHIST'
+                                        WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'
+                                        WHEN 7 THEN 'BOUNDS_HISTOGRAM'
+                                    END::text
+                                    ORDER BY kind.ord)
+                            FROM unnest(ARRAY[s.stakind1, s.stakind2,
+                                        s.stakind3, stakind4,
+                                        s.stakind5])
+                                 WITH ORDINALITY AS kind(kind, ord)
+                        ),
+                        'stanumbers',
+                        jsonb_build_array(
+                            s.stanumbers1::text::text[],
+                            s.stanumbers2::text::text[],
+                            s.stanumbers3::text::text[],
+                            s.stanumbers4::text::text[],
+                            s.stanumbers5::text::text[]),
+                        'stavalues',
+                        jsonb_build_array(
+                            s.stavalues1::text::text[],
+                            s.stavalues2::text::text[],
+                            s.stavalues3::text::text[],
+                            s.stavalues4::text::text[],
+                            s.stavalues5::text::text[])
+                    ) AS stats
+                FROM pg_attribute AS a
+                JOIN pg_statistic AS s
+                    ON s.starelid = a.attrelid
+                    AND s.staattnum = a.attnum
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+                AND has_column_privilege(a.attrelid, a.attnum, 'SELECT')
+            ),
+            attagg AS
+            (
+                SELECT
+                    pcs.stainherit,
+                    jsonb_build_object(
+                        'columns',
+                        jsonb_object_agg(
+                            pcs.attname,
+                            pcs.stats
+                        )
+                    ) AS stats
+                FROM per_column_stats AS pcs
+                GROUP BY pcs.stainherit
+            ),
+            extended_object_stats AS
+            (
+                SELECT
+                    sd.stxdinherit,
+                    e.stxname,
+                    jsonb_build_object(
+                        'stxkinds',
+                        to_jsonb(e.stxkind),
+                        'stxdndistinct',
+                        ndist.stxdndistinct,
+                        'stxdndependencies',
+                        ndep.stxdndependencies,
+                        'stxdmcv',
+                        mcv.stxdmcv,
+                        'stxdexprs',
+                        x.stdxdexprs
+                    ) AS stats
+                FROM pg_statistic_ext AS e
+                JOIN pg_statistic_ext_data AS sd
+                    ON sd.stxoid = e.oid
+                LEFT JOIN LATERAL
+                    (
+                        -- att1 [, att2..]: ndistinct
+                        SELECT
+                            jsonb_agg(
+                                jsonb_build_object(
+                                    'attnums', string_to_array(nd.attnums, ', '),
+                                    'ndistinct', nd.ndistinct
+                                    )
+                                ORDER BY nd.ord
+                            )
+                        -- jsonb does not preserve parsed order so use json
+                        FROM json_each_text(sd.stxdndistinct::text::json)
+                             WITH ORDINALITY AS nd(attnums, ndistinct, ord)
+                    ) AS ndist(stxdndistinct) ON sd.stxdndistinct IS NOT NULL
+                LEFT JOIN LATERAL
+                    (
+                        -- att1, [, att2 ...] => attN: degree
+                        SELECT
+                            jsonb_agg(
+                                jsonb_build_object(
+                                    'attnums',
+                                    string_to_array( replace(dep.attrs, ' => ', ', '), ', '),
+                                    'degree',
+                                    dep.degree
+                                    )
+                                ORDER BY dep.ord
+                            )
+                        -- jsonb does not preserve parsed order so use json
+                        FROM json_each_text(sd.stxddependencies::text::json)
+                             WITH ORDINALITY AS dep(attrs, degree, ord)
+                    ) AS ndep(stxdndependencies) ON sd.stxddependencies IS NOT NULL
+                LEFT JOIN LATERAL
+                    (
+                        -- TODO SELECT sd.stxdmcv
+                        SELECT NULL AS stxdmcv
+                    ) AS mcv(stxdmcv) ON sd.stxdmcv IS NOT NULL
+                LEFT JOIN LATERAL
+                    (
+                        SELECT
+                            jsonb_agg(
+                                jsonb_build_object(
+                                    'stanullfrac', s.stanullfrac::text,
+                                    'stawidth', s.stawidth::text,
+                                    'stadistinct', s.stadistinct::text,
+                                    'stakinds',
+                                    (
+                                        SELECT
+                                            jsonb_agg(
+                                                CASE kind.kind
+                                                    WHEN 0 THEN 'TRIVIAL'
+                                                    WHEN 1 THEN 'MCV'
+                                                    WHEN 2 THEN 'HISTOGRAM'
+                                                    WHEN 3 THEN 'CORRELATION'
+                                                    WHEN 4 THEN 'MCELEM'
+                                                    WHEN 5 THEN 'DECHIST'
+                                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'
+                                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM'
+                                                END::text
+                                                ORDER BY kind.ord)
+                                        FROM unnest(ARRAY[s.stakind1, s.stakind2,
+                                                    s.stakind3, stakind4,
+                                                    s.stakind5]) WITH ORDINALITY AS kind(kind, ord)
+                                    ),
+                                    'stanumbers',
+                                    jsonb_build_array(
+                                        s.stanumbers1::text::text[],
+                                        s.stanumbers2::text::text[],
+                                        s.stanumbers3::text::text[],
+                                        s.stanumbers4::text::text[],
+                                        s.stanumbers5::text::text[]),
+                                    'stavalues',
+                                    jsonb_build_array(
+                                        s.stavalues1::text::text[],
+                                        s.stavalues2::text::text[],
+                                        s.stavalues3::text::text[],
+                                        s.stavalues4::text::text[],
+                                        s.stavalues5::text::text[])
+                                )
+                                ORDER BY s.ordinality
+                            )
+                        FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s
+                    ) AS x(stdxdexprs) ON sd.stxdexpr IS NOT NULL
+                WHERE e.stxrelid = r.oid
+            ),
+            extagg AS
+            (
+                SELECT
+                    eos.stxdinherit,
+                    jsonb_build_object(
+                        'extended',
+                        jsonb_object_agg(
+                            eos.stxname,
+                            eos.stats
+                        )
+                    ) AS stats
+                FROM extended_object_stats AS eos
+                GROUP BY eos.stxdinherit
+            )
+            SELECT
+                jsonb_object_agg(
+                    CASE coalesce(a.stainherit, e.stxdinherit)
+                        WHEN TRUE THEN 'inherited'
+                        ELSE 'regular'
+                    END,
+                    coalesce(a.stats, '{}'::jsonb) || coalesce(e.stats, '{}'::jsonb)
+                )
+            FROM attagg AS a
+            FULL OUTER JOIN extagg e ON a.stainherit = e.stxdinherit
+        ) AS stats
+    FROM pg_class AS r
+    JOIN pg_namespace AS n
+        ON n.oid = r.relnamespace
+    WHERE relkind IN ('r', 'm', 'f', 'p')
+    AND n.nspname NOT IN ('pg_catalog', 'information_schema');
+
+
 CREATE VIEW pg_stats_ext WITH (security_barrier) AS
     SELECT cn.nspname AS schemaname,
            c.relname AS tablename,
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 1442c43d9c..20ab4da385 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -2404,6 +2404,77 @@ pg_statio_user_tables| SELECT relid,
     tidx_blks_hit
    FROM pg_statio_all_tables
   WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text));
+pg_statistic_export| SELECT n.nspname AS schemaname,
+    r.relname,
+    (current_setting('server_version_num'::text))::integer AS server_version_num,
+    r.reltuples AS n_tuples,
+    r.relpages AS n_pages,
+    ( WITH per_column_stats AS (
+                 SELECT s.stainherit,
+                    a_1.attname,
+                    jsonb_build_object('stanullfrac', (s.stanullfrac)::text, 'stawidth', (s.stawidth)::text, 'stadistinct', (s.stadistinct)::text, 'stakinds', ( SELECT jsonb_agg(
+                                CASE kind.kind
+                                    WHEN 0 THEN 'TRIVIAL'::text
+                                    WHEN 1 THEN 'MCV'::text
+                                    WHEN 2 THEN 'HISTOGRAM'::text
+                                    WHEN 3 THEN 'CORRELATION'::text
+                                    WHEN 4 THEN 'MCELEM'::text
+                                    WHEN 5 THEN 'DECHIST'::text
+                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'::text
+                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM'::text
+                                    ELSE NULL::text
+                                END ORDER BY kind.ord) AS jsonb_agg
+                           FROM unnest(ARRAY[s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5]) WITH ORDINALITY kind(kind, ord)), 'stanumbers', jsonb_build_array(((s.stanumbers1)::text)::text[], ((s.stanumbers2)::text)::text[], ((s.stanumbers3)::text)::text[], ((s.stanumbers4)::text)::text[], ((s.stanumbers5)::text)::text[]), 'stavalues', jsonb_build_array(((s.stavalues1)::text)::text[], ((s.stavalues2)::text)::text[], ((s.stavalues3)::text)::text[], ((s.stavalues4)::text)::text[], ((s.stavalues5)::text)::text[])) AS stats
+                   FROM (pg_attribute a_1
+                     JOIN pg_statistic s ON (((s.starelid = a_1.attrelid) AND (s.staattnum = a_1.attnum))))
+                  WHERE ((a_1.attrelid = r.oid) AND (NOT a_1.attisdropped) AND (a_1.attnum > 0) AND has_column_privilege(a_1.attrelid, a_1.attnum, 'SELECT'::text))
+                ), attagg AS (
+                 SELECT pcs.stainherit,
+                    jsonb_build_object('columns', jsonb_object_agg(pcs.attname, pcs.stats)) AS stats
+                   FROM per_column_stats pcs
+                  GROUP BY pcs.stainherit
+                ), extended_object_stats AS (
+                 SELECT sd.stxdinherit,
+                    e_1.stxname,
+                    jsonb_build_object('stxkinds', to_jsonb(e_1.stxkind), 'stxdndistinct', ndist.stxdndistinct, 'stxdndependencies', ndep.stxdndependencies, 'stxdmcv', mcv.stxdmcv, 'stxdexprs', x.stdxdexprs) AS stats
+                   FROM (((((pg_statistic_ext e_1
+                     JOIN pg_statistic_ext_data sd ON ((sd.stxoid = e_1.oid)))
+                     LEFT JOIN LATERAL ( SELECT jsonb_agg(jsonb_build_object('attnums', string_to_array(nd.attnums, ', '::text), 'ndistinct', nd.ndistinct) ORDER BY nd.ord) AS jsonb_agg
+                           FROM json_each_text(((sd.stxdndistinct)::text)::json) WITH ORDINALITY nd(attnums, ndistinct, ord)) ndist(stxdndistinct) ON ((sd.stxdndistinct IS NOT NULL)))
+                     LEFT JOIN LATERAL ( SELECT jsonb_agg(jsonb_build_object('attnums', string_to_array(replace(dep.attrs, ' => '::text, ', '::text), ', '::text), 'degree', dep.degree) ORDER BY dep.ord) AS jsonb_agg
+                           FROM json_each_text(((sd.stxddependencies)::text)::json) WITH ORDINALITY dep(attrs, degree, ord)) ndep(stxdndependencies) ON ((sd.stxddependencies IS NOT NULL)))
+                     LEFT JOIN LATERAL ( SELECT NULL::text AS stxdmcv) mcv(stxdmcv) ON ((sd.stxdmcv IS NOT NULL)))
+                     LEFT JOIN LATERAL ( SELECT jsonb_agg(jsonb_build_object('stanullfrac', (s.stanullfrac)::text, 'stawidth', (s.stawidth)::text, 'stadistinct', (s.stadistinct)::text, 'stakinds', ( SELECT jsonb_agg(
+CASE kind.kind
+ WHEN 0 THEN 'TRIVIAL'::text
+ WHEN 1 THEN 'MCV'::text
+ WHEN 2 THEN 'HISTOGRAM'::text
+ WHEN 3 THEN 'CORRELATION'::text
+ WHEN 4 THEN 'MCELEM'::text
+ WHEN 5 THEN 'DECHIST'::text
+ WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'::text
+ WHEN 7 THEN 'BOUNDS_HISTOGRAM'::text
+ ELSE NULL::text
+END ORDER BY kind.ord) AS jsonb_agg
+                                   FROM unnest(ARRAY[s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5]) WITH ORDINALITY kind(kind, ord)), 'stanumbers', jsonb_build_array(((s.stanumbers1)::text)::text[], ((s.stanumbers2)::text)::text[], ((s.stanumbers3)::text)::text[], ((s.stanumbers4)::text)::text[], ((s.stanumbers5)::text)::text[]), 'stavalues', jsonb_build_array(((s.stavalues1)::text)::text[], ((s.stavalues2)::text)::text[], ((s.stavalues3)::text)::text[], ((s.stavalues4)::text)::text[], ((s.stavalues5)::text)::text[])) ORDER BY s.ordinality) AS jsonb_agg
+                           FROM unnest(sd.stxdexpr) WITH ORDINALITY s(starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5, ordinality)) x(stdxdexprs) ON ((sd.stxdexpr IS NOT NULL)))
+                  WHERE (e_1.stxrelid = r.oid)
+                ), extagg AS (
+                 SELECT eos.stxdinherit,
+                    jsonb_build_object('extended', jsonb_object_agg(eos.stxname, eos.stats)) AS stats
+                   FROM extended_object_stats eos
+                  GROUP BY eos.stxdinherit
+                )
+         SELECT jsonb_object_agg(
+                CASE COALESCE(a.stainherit, e.stxdinherit)
+                    WHEN true THEN 'inherited'::text
+                    ELSE 'regular'::text
+                END, (COALESCE(a.stats, '{}'::jsonb) || COALESCE(e.stats, '{}'::jsonb))) AS jsonb_object_agg
+           FROM (attagg a
+             FULL JOIN extagg e ON ((a.stainherit = e.stxdinherit)))) AS stats
+   FROM (pg_class r
+     JOIN pg_namespace n ON ((n.oid = r.relnamespace)))
+  WHERE ((r.relkind = ANY (ARRAY['r'::"char", 'm'::"char", 'f'::"char", 'p'::"char"])) AND (n.nspname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])));
 pg_stats| SELECT n.nspname AS schemaname,
     c.relname AS tablename,
     a.attname,
diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 7078491c4c..24b44ab388 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -191,6 +191,11 @@
       <entry>extended planner statistics for expressions</entry>
      </row>
 
+     <row>
+      <entry><link linkend="view-pg-stats"><structname>pg_stats_export</structname></link></entry>
+      <entry>planner statistics for export/upgrade purposes</entry>
+     </row>
+
      <row>
       <entry><link linkend="view-pg-tables"><structname>pg_tables</structname></link></entry>
       <entry>tables</entry>
-- 
2.41.0

From 05b0a3537765a85fda8b59912b658eec1e6b5a81 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 31 Oct 2023 03:12:45 -0400
Subject: [PATCH v2 3/4] Add pg_import_rel_stats().

The function pg_import_rel_stats imports rowcount, pagecount, and column
statistics for a given table, as well as column statistics for the
underlying indexes and extended statistics for any named statistics
objects for that table.

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a best-effort approach, skipping statistics that are
expected but omitted, skipping object that are specified but do not
exist on the target system. The goal is to get better-than-empty
statistics into the table quickly, so that business operations can
resume sooner.

It should be noted that index statistics _are_ rebuilt as normal, but
use the imported column statistics from the table, so it is not
necessary for the indexes on the target table to match the indexes on
the extracted source table.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

Extended statistics are identified by name, so those names on the target
system must match the source. If not, they are skipped.

While the column, index column, and extended statistics are applied
transactionally, the changes to pg_class (reltuples and relpages) are
not. This decision was made to avoid bloat of pg_class and is in line
with the behavior of VACUUM.

The medium of exchange is jsonb, the format of which is specified in the
view pg_statistic_export. Obviously this view does not exist in older
versions of the database, but the view definition can be extracted and
adapted to older versions.

This function also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   5 +
 src/include/commands/vacuum.h                 |   4 +
 .../statistics/extended_stats_internal.h      |   3 +
 src/include/statistics/statistics.h           |  10 +
 src/backend/commands/analyze.c                | 709 ++++++++++++++++--
 src/backend/statistics/dependencies.c         | 133 ++++
 src/backend/statistics/extended_stats.c       | 259 +++++++
 src/backend/statistics/mcv.c                  |   6 +
 src/backend/statistics/mvdistinct.c           | 120 +++
 src/test/regress/expected/vacuum.out          | 153 ++++
 src/test/regress/sql/vacuum.sql               | 146 ++++
 doc/src/sgml/func.sgml                        |  42 ++
 12 files changed, 1527 insertions(+), 63 deletions(-)

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 568aa80d92..01aeb54fe3 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5639,6 +5639,11 @@
   proname => 'pg_stat_get_db_checksum_last_failure', provolatile => 's',
   proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
   prosrc => 'pg_stat_get_db_checksum_last_failure' },
+{ oid => '3813',
+  descr => 'statistics: import to relation',
+  proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid int4 float4 int4 jsonb',
+  prosrc => 'pg_import_rel_stats' },
 { oid => '3074', descr => 'statistics: last reset for a database',
   proname => 'pg_stat_get_db_stat_reset_time', provolatile => 's',
   proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
index 4af02940c5..72c31eb882 100644
--- a/src/include/commands/vacuum.h
+++ b/src/include/commands/vacuum.h
@@ -24,6 +24,7 @@
 #include "storage/buf.h"
 #include "storage/lock.h"
 #include "utils/relcache.h"
+#include "utils/jsonb.h"
 
 /*
  * Flags for amparallelvacuumoptions to control the participation of bulkdelete
@@ -386,4 +387,7 @@ extern double anl_random_fract(void);
 extern double anl_init_selection_state(int n);
 extern double anl_get_next_S(double t, int n, double *stateptr);
 
+extern Datum pg_import_rel_stats(PG_FUNCTION_ARGS);
+
+
 #endif							/* VACUUM_H */
diff --git a/src/include/statistics/extended_stats_internal.h b/src/include/statistics/extended_stats_internal.h
index 7b55eb8ffa..fdefaa28f5 100644
--- a/src/include/statistics/extended_stats_internal.h
+++ b/src/include/statistics/extended_stats_internal.h
@@ -72,15 +72,18 @@ typedef struct StatsBuildData
 extern MVNDistinct *statext_ndistinct_build(double totalrows, StatsBuildData *data);
 extern bytea *statext_ndistinct_serialize(MVNDistinct *ndistinct);
 extern MVNDistinct *statext_ndistinct_deserialize(bytea *data);
+extern MVNDistinct *import_ndistinct(JsonbContainer *cont);
 
 extern MVDependencies *statext_dependencies_build(StatsBuildData *data);
 extern bytea *statext_dependencies_serialize(MVDependencies *dependencies);
 extern MVDependencies *statext_dependencies_deserialize(bytea *data);
+extern MVDependencies * import_dependencies(JsonbContainer *cont);
 
 extern MCVList *statext_mcv_build(StatsBuildData *data,
 								  double totalrows, int stattarget);
 extern bytea *statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats);
 extern MCVList *statext_mcv_deserialize(bytea *data);
+extern MCVList *import_mcv(JsonbContainer *cont);
 
 extern MultiSortSupport multi_sort_init(int ndims);
 extern void multi_sort_add_dimension(MultiSortSupport mss, int sortdim,
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 5e538fec32..2b37e77887 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -101,6 +101,7 @@ extern MCVList *statext_mcv_load(Oid mvoid, bool inh);
 extern void BuildRelationExtStatistics(Relation onerel, bool inh, double totalrows,
 									   int numrows, HeapTuple *rows,
 									   int natts, VacAttrStats **vacattrstats);
+
 extern int	ComputeExtStatisticsRows(Relation onerel,
 									 int natts, VacAttrStats **vacattrstats);
 extern bool statext_is_kind_built(HeapTuple htup, char type);
@@ -127,4 +128,13 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern void ImportVacAttrStats( VacAttrStats *stats, JsonbContainer *cont);
+extern void ImportRelationExtStatistics(Relation onerel, bool inh, int natts,
+										VacAttrStats **vacattrstats,
+										JsonbContainer *cont);
+
+extern char *key_lookup_cstring(JsonbContainer *cont, const char *key);
+extern JsonbContainer *key_lookup_object(JsonbContainer *cont, const char *key);
+extern JsonbContainer *key_lookup_array(JsonbContainer *cont, const char *key);
+
 #endif							/* STATISTICS_H */
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 206d1689ef..a9715c3eb3 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -18,6 +18,7 @@
 
 #include "access/detoast.h"
 #include "access/genam.h"
+#include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relation.h"
 #include "access/sysattr.h"
@@ -33,6 +34,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_inherits.h"
 #include "catalog/pg_namespace.h"
+#include "catalog/pg_operator.h"
 #include "catalog/pg_statistic_ext.h"
 #include "commands/dbcommands.h"
 #include "commands/progress.h"
@@ -40,6 +42,7 @@
 #include "commands/vacuum.h"
 #include "common/pg_prng.h"
 #include "executor/executor.h"
+#include "fmgr.h"
 #include "foreign/fdwapi.h"
 #include "miscadmin.h"
 #include "nodes/nodeFuncs.h"
@@ -57,16 +60,20 @@
 #include "utils/attoptcache.h"
 #include "utils/builtins.h"
 #include "utils/datum.h"
+#include "utils/float.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
+#include "utils/jsonb.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/numeric.h"
 #include "utils/pg_rusage.h"
 #include "utils/sampling.h"
 #include "utils/sortsupport.h"
 #include "utils/spccache.h"
 #include "utils/syscache.h"
 #include "utils/timestamp.h"
+#include "utils/typcache.h"
 
 
 /* Per-index data for ANALYZE */
@@ -109,6 +116,12 @@ static void update_attstats(Oid relid, bool inh,
 static Datum std_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull);
 static Datum ind_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull);
 
+static AnlIndexData *build_indexdata(Relation onerel, Relation *Irel,
+									 int nindexes, bool all_columns);
+static VacAttrStats **examine_rel_attributes(Relation onerel, int *attr_cnt);
+
+static
+void import_pg_statistics(Relation onerel, bool inh, JsonbContainer *cont);
 
 /*
  *	analyze_rel() -- analyze one relation
@@ -403,29 +416,8 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
 		attr_cnt = tcnt;
 	}
 	else
-	{
-		attr_cnt = onerel->rd_att->natts;
-		vacattrstats = (VacAttrStats **)
-			palloc(attr_cnt * sizeof(VacAttrStats *));
-		tcnt = 0;
-		for (i = 1; i <= attr_cnt; i++)
-		{
-			vacattrstats[tcnt] = examine_attribute(onerel, i, NULL);
-			if (vacattrstats[tcnt] != NULL)
-				tcnt++;
-		}
-		attr_cnt = tcnt;
-	}
+		vacattrstats = examine_rel_attributes(onerel, &attr_cnt);
 
-	/*
-	 * Open all indexes of the relation, and see if there are any analyzable
-	 * columns in the indexes.  We do not analyze index columns if there was
-	 * an explicit column list in the ANALYZE command, however.
-	 *
-	 * If we are doing a recursive scan, we don't want to touch the parent's
-	 * indexes at all.  If we're processing a partitioned table, we need to
-	 * know if there are any indexes, but we don't want to process them.
-	 */
 	if (onerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		List	   *idxs = RelationGetIndexList(onerel);
@@ -446,48 +438,8 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
 		nindexes = 0;
 		hasindex = false;
 	}
-	indexdata = NULL;
-	if (nindexes > 0)
-	{
-		indexdata = (AnlIndexData *) palloc0(nindexes * sizeof(AnlIndexData));
-		for (ind = 0; ind < nindexes; ind++)
-		{
-			AnlIndexData *thisdata = &indexdata[ind];
-			IndexInfo  *indexInfo;
 
-			thisdata->indexInfo = indexInfo = BuildIndexInfo(Irel[ind]);
-			thisdata->tupleFract = 1.0; /* fix later if partial */
-			if (indexInfo->ii_Expressions != NIL && va_cols == NIL)
-			{
-				ListCell   *indexpr_item = list_head(indexInfo->ii_Expressions);
-
-				thisdata->vacattrstats = (VacAttrStats **)
-					palloc(indexInfo->ii_NumIndexAttrs * sizeof(VacAttrStats *));
-				tcnt = 0;
-				for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
-				{
-					int			keycol = indexInfo->ii_IndexAttrNumbers[i];
-
-					if (keycol == 0)
-					{
-						/* Found an index expression */
-						Node	   *indexkey;
-
-						if (indexpr_item == NULL)	/* shouldn't happen */
-							elog(ERROR, "too few entries in indexprs list");
-						indexkey = (Node *) lfirst(indexpr_item);
-						indexpr_item = lnext(indexInfo->ii_Expressions,
-											 indexpr_item);
-						thisdata->vacattrstats[tcnt] =
-							examine_attribute(Irel[ind], i + 1, indexkey);
-						if (thisdata->vacattrstats[tcnt] != NULL)
-							tcnt++;
-					}
-				}
-				thisdata->attr_cnt = tcnt;
-			}
-		}
-	}
+	indexdata = build_indexdata(onerel, Irel, nindexes, (va_cols == NIL));
 
 	/*
 	 * Determine how many rows we need to sample, using the worst case from
@@ -823,6 +775,92 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
 	anl_context = NULL;
 }
 
+
+/*
+ * Create VacAttrStats entries for all attributes in a relation.
+ */
+static
+VacAttrStats **examine_rel_attributes(Relation onerel, int *attr_cnt)
+{
+	int natts = onerel->rd_att->natts;
+	int nfound = 0;
+	int i;
+	VacAttrStats **attrstats;
+
+	*attr_cnt = natts;
+	attrstats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
+	for (i = 1; i <= natts; i++)
+	{
+		attrstats[nfound] = examine_attribute(onerel, i, NULL);
+		if (attrstats[nfound] != NULL)
+			nfound++;
+	}
+	*attr_cnt = nfound;
+	return attrstats;
+}
+
+/*
+ * Open all indexes of the relation, and see if there are any analyzable
+ * columns in the indexes.  We do not analyze index columns if there was
+ * an explicit column list in the ANALYZE command, however.
+ *
+ * If we are doing a recursive scan, we don't want to touch the parent's
+ * indexes at all.  If we're processing a partitioned table, we need to
+ * know if there are any indexes, but we don't want to process them.
+ */
+static
+AnlIndexData *build_indexdata(Relation onerel, Relation *Irel, int nindexes, bool all_columns)
+{
+	AnlIndexData   *indexdata;
+	int				ind,
+					tcnt,
+					i;
+
+	if (nindexes == 0)
+		return NULL;
+
+	indexdata = (AnlIndexData *) palloc0(nindexes * sizeof(AnlIndexData));
+
+	for (ind = 0; ind < nindexes; ind++)
+	{
+		AnlIndexData *thisdata = &indexdata[ind];
+		IndexInfo  *indexInfo;
+
+		thisdata->indexInfo = indexInfo = BuildIndexInfo(Irel[ind]);
+		thisdata->tupleFract = 1.0; /* fix later if partial */
+		if (indexInfo->ii_Expressions != NIL && all_columns)
+		{
+			ListCell   *indexpr_item = list_head(indexInfo->ii_Expressions);
+
+			thisdata->vacattrstats = (VacAttrStats **)
+				palloc(indexInfo->ii_NumIndexAttrs * sizeof(VacAttrStats *));
+			tcnt = 0;
+			for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
+			{
+				int			keycol = indexInfo->ii_IndexAttrNumbers[i];
+
+				if (keycol == 0)
+				{
+					/* Found an index expression */
+					Node	   *indexkey;
+
+					if (indexpr_item == NULL)	/* shouldn't happen */
+						elog(ERROR, "too few entries in indexprs list");
+					indexkey = (Node *) lfirst(indexpr_item);
+					indexpr_item = lnext(indexInfo->ii_Expressions,
+										 indexpr_item);
+					thisdata->vacattrstats[tcnt] =
+						examine_attribute(Irel[ind], i + 1, indexkey);
+					if (thisdata->vacattrstats[tcnt] != NULL)
+						tcnt++;
+				}
+			}
+			thisdata->attr_cnt = tcnt;
+		}
+	}
+	return indexdata;
+}
+
 /*
  * Compute statistics about indexes of a relation
  */
@@ -3073,3 +3111,548 @@ analyze_mcv_list(int *mcv_counts,
 	}
 	return num_mcv;
 }
+
+/*
+ * Get a JsonbValue from a JsonbContainer and ensure that it is a string,
+ * and return the cstring.
+ */
+char *key_lookup_cstring(JsonbContainer *cont, const char *key)
+{
+	JsonbValue	j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvString)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be a string but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	return JsonbStringValueToCString(&j);
+}
+
+/*
+ * Get a JsonbContainer from a JsonbContainer and ensure that it is a object
+ */
+JsonbContainer *key_lookup_object(JsonbContainer *cont, const char *key)
+{
+	JsonbValue	j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvBinary)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an object but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	if (!JsonContainerIsObject(j.val.binary.data))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an object but is type %s",
+				  key, JsonbContainerTypeName(j.val.binary.data))));
+
+	return j.val.binary.data;
+}
+
+/*
+ * Get a JsonbContainer from a JsonbContainer and ensure that it is an array
+ */
+JsonbContainer *key_lookup_array(JsonbContainer *cont, const char *key)
+{
+	JsonbValue	j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvBinary)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an array but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	if (!JsonContainerIsArray(j.val.binary.data))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an array but is type %s",
+				  key, JsonbContainerTypeName(j.val.binary.data))));
+
+	return j.val.binary.data;
+}
+
+/*
+ * Import statistics from JSONB export into relation
+ *
+ * Format is:
+ *
+ * {
+ *   "columns": { "colname1": ... },
+ *   "extended": { "statname1": ...}
+ * }
+ */
+Datum
+pg_import_rel_stats(PG_FUNCTION_ARGS)
+{
+	Oid			relid;
+	int32		stats_version_num;
+	Jsonb	   *jb;
+	Relation	onerel;
+	Oid			save_userid;
+	int			save_sec_context;
+	int			save_nestlevel;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("relation cannot be NULL")));
+	relid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("server_version_number cannot be NULL")));
+	stats_version_num = PG_GETARG_INT32(1);
+
+	if (stats_version_num < 80000)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics version: %d is earlier than earliest supported version",
+				  stats_version_num)));
+
+	if (PG_ARGISNULL(4))
+		jb = NULL;
+	else
+	{
+		jb = PG_GETARG_JSONB_P(4);
+		if (!JB_ROOT_IS_OBJECT(jb))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("columns must be jsonb object at root")));
+	}
+
+	onerel = vacuum_open_relation(relid, NULL, VACOPT_ANALYZE, true,
+								  ShareUpdateExclusiveLock);
+
+	if (onerel == NULL)
+		PG_RETURN_BOOL(false);
+
+	if (!vacuum_is_relation_owner(RelationGetRelid(onerel),
+								onerel->rd_rel,
+								VACOPT_ANALYZE))
+	{
+		relation_close(onerel, ShareUpdateExclusiveLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * Switch to the table owner's userid, so that any index functions are run
+	 * as that user.  Also lock down security-restricted operations and
+	 * arrange to make GUC variable changes local to this command.
+	 */
+	GetUserIdAndSecContext(&save_userid, &save_sec_context);
+	SetUserIdAndSecContext(onerel->rd_rel->relowner,
+						   save_sec_context | SECURITY_RESTRICTED_OPERATION);
+	save_nestlevel = NewGUCNestLevel();
+
+	/*
+	 * Apply statistical updates, if any, to copied tuple.
+	 *
+	 * Format is:
+	 * {
+	 *   "regular": { "columns": ..., "extended": ...},
+	 *   "inherited": { "columns": ..., "extended": ...}
+	 * }
+	 *
+	 */
+	if (jb != NULL)
+	{
+		JsonbContainer	   *cont;
+
+		cont = key_lookup_object(&jb->root, "regular");
+		import_pg_statistics(onerel, false, cont);
+
+		if (onerel->rd_rel->relhassubclass)
+		{
+			cont = key_lookup_object(&jb->root, "inherited");
+			import_pg_statistics(onerel, true, cont);
+		}
+	}
+
+	/* only modify pg_class row if changes are to be made */
+	if ( ! PG_ARGISNULL(2) || ! PG_ARGISNULL(3) )
+	{
+		Relation		pg_class_rel;
+		HeapTuple		ctup;
+		Form_pg_class	pgcform;
+
+		/*
+		 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+		 * other stat-setting operation can run on it concurrently.
+		 */
+		pg_class_rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+		/* leave if relation could not be opened or locked */
+		if (!pg_class_rel)
+			PG_RETURN_BOOL(false);
+
+		ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+		if (!HeapTupleIsValid(ctup))
+			elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+				 relid);
+		pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+		/* leave un-set values alone */
+		if (! PG_ARGISNULL(2))
+			pgcform->reltuples = PG_GETARG_FLOAT4(2);
+		if (! PG_ARGISNULL(3))
+			pgcform->relpages = PG_GETARG_INT32(3);
+
+		heap_inplace_update(pg_class_rel, ctup);
+		table_close(pg_class_rel, ShareUpdateExclusiveLock);
+	}
+
+	/* relation_close(onerel, ShareUpdateExclusiveLock); */
+	relation_close(onerel, NoLock);
+
+	/* Roll back any GUC changes executed by index functions */
+	AtEOXact_GUC(false, save_nestlevel);
+
+	/* Restore userid and security context */
+	SetUserIdAndSecContext(save_userid, save_sec_context);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Convert the STATISTICS_KIND strings defined in pg_statistic_export
+ * back to their defined enum values.
+ */
+static int16
+decode_stakind_string(char *s)
+{
+	if (strcmp(s,"MCV") == 0)
+		return STATISTIC_KIND_MCV;
+	if (strcmp(s,"HISTOGRAM") == 0)
+		return STATISTIC_KIND_HISTOGRAM;
+	if (strcmp(s,"CORRELATION") == 0)
+		return STATISTIC_KIND_CORRELATION;
+	if (strcmp(s,"MCELEM") == 0)
+		return STATISTIC_KIND_MCELEM;
+	if (strcmp(s,"DECHIST") == 0)
+		return STATISTIC_KIND_DECHIST;
+	if (strcmp(s,"RANGE_LENGTH_HISTOGRAM") == 0)
+		return STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM;
+	if (strcmp(s,"BOUNDS_HISTOGRAM") == 0)
+		return STATISTIC_KIND_BOUNDS_HISTOGRAM;
+	if (strcmp(s,"TRIVIAL") != 0)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("unknown statistics kind: %s", s)));
+
+	return 0;
+}
+
+/*
+ *
+ * Format is:
+ *
+ * {
+ *   "regular":
+ *     {
+ *       "columns": { "colname1": ... }},
+ *       "extended": { "statname1": ...}
+ *     },
+ *   "inherited":
+ *     {
+ *       "columns": { "colname1": ... }},
+ *       "extended": { "statname1": ...}
+ *     },
+ * }
+ */
+static
+void import_pg_statistics(Relation onerel, bool inh, JsonbContainer *cont)
+{
+	VacAttrStats	  **vacattrstats;
+	JsonbContainer	   *colscont;
+	JsonbContainer	   *extscont;
+	int					natts;
+	AnlIndexData	   *indexdata = NULL;
+	int					nindexes = 0;
+	int					i,
+						ind;
+	Relation		   *Irel = NULL;
+
+	/* skip if no statistics of this inheritance type available */
+	if (cont == NULL)
+		return;
+
+	vacattrstats = examine_rel_attributes(onerel, &natts);
+
+	if ((!inh) &&
+		(onerel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE))
+	{
+		vac_open_indexes(onerel, AccessShareLock, &nindexes, &Irel);
+		if (nindexes > 0)
+			indexdata = build_indexdata(onerel, Irel, nindexes, true);
+	}
+
+	colscont = key_lookup_object(cont, "columns");
+	if (colscont != NULL)
+	{
+		for (i = 0; i < natts; i++)
+		{
+			VacAttrStats   *stats;
+			JsonbContainer *attrcont;
+			const char	   *name;
+
+			stats = vacattrstats[i];
+			name = NameStr(*attnumAttName(onerel, stats->tupattnum));
+
+			attrcont = key_lookup_object(colscont, name);
+			ImportVacAttrStats(stats, attrcont);
+		}
+		update_attstats(RelationGetRelid(onerel), inh, natts, vacattrstats);
+
+		/* now compute the index stats based on imported table stats */
+		for (ind = 0; ind < nindexes; ind++)
+		{
+			AnlIndexData *thisdata = &indexdata[ind];
+
+			update_attstats(RelationGetRelid(Irel[ind]), false,
+							thisdata->attr_cnt, thisdata->vacattrstats);
+		}
+	}
+
+	extscont = key_lookup_object(cont, "extended");
+
+	if (extscont != NULL)
+	{
+		/* Build extended statistics (if there are any). */
+
+		ImportRelationExtStatistics(onerel, false, natts, vacattrstats, extscont);
+
+		if (onerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			ImportRelationExtStatistics(onerel, true, natts, vacattrstats, extscont);
+	}
+
+	if ((!inh) &&
+		(onerel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE))
+		vac_close_indexes(nindexes, Irel, NoLock);
+}
+
+/*
+ * Apply all found statistics within a JSON structure to a pre-examined
+ * VacAttrStats.
+ */
+void
+ImportVacAttrStats( VacAttrStats *stats, JsonbContainer *cont)
+{
+	JsonbContainer *arraycont;
+	char		   *s;
+	int				k;
+
+	/* nothing to import, skip */
+	if (cont == NULL)
+		return;
+
+	stats->stats_valid = true;
+
+	s = key_lookup_cstring(cont, "stanullfrac");
+	if (s != NULL)
+	{
+		stats->stanullfrac = float4in_internal(s, NULL, "real", s, NULL);
+		pfree(s);
+	}
+	s = key_lookup_cstring(cont, "stawidth");
+	if (s != NULL)
+	{
+		stats->stawidth = pg_strtoint32(s);
+		pfree(s);
+	}
+
+	s = key_lookup_cstring(cont, "stadistinct");
+	if (s != NULL)
+	{
+		stats->stadistinct = float4in_internal(s, NULL, "real", s, NULL);
+		pfree(s);
+	}
+
+	arraycont = key_lookup_array(cont, "stakinds");
+	if (arraycont != NULL)
+	{
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			StdAnalyzeData *mystats;
+			JsonbValue	   *e;
+			char		   *stakindstr;
+
+			mystats = (StdAnalyzeData *) stats->extra_data;
+			e = getIthJsonbValueFromContainer(arraycont, k);
+
+			if (e == NULL || (e->type != jbvString))
+				ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					errmsg("invalid format: stakind elements must be strings")));
+
+			stakindstr = JsonbStringValueToCString(e);
+			stats->stakind[k] = decode_stakind_string(stakindstr);
+			pfree(stakindstr);
+			pfree(e);
+
+			switch(stats->stakind[k])
+			{
+				case STATISTIC_KIND_MCV:
+				case STATISTIC_KIND_DECHIST:
+					stats->staop[k] = mystats->eqopr;
+					stats->stacoll[k] = stats->attrcollid;
+					break;
+
+				case STATISTIC_KIND_HISTOGRAM:
+				case STATISTIC_KIND_CORRELATION:
+					stats->staop[k] = mystats->ltopr;
+					stats->stacoll[k] = stats->attrcollid;
+					break;
+
+				case STATISTIC_KIND_MCELEM:
+					stats->staop[k] = TextEqualOperator;
+					stats->stacoll[k] = DEFAULT_COLLATION_OID;
+					break;
+
+				case STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM:
+					stats->staop[k] = Float8LessOperator;
+					stats->stacoll[k] = InvalidOid;
+					break;
+
+				case STATISTIC_KIND_BOUNDS_HISTOGRAM:
+				default:
+					stats->staop[k] = InvalidOid;
+					stats->stacoll[k] = InvalidOid;
+					break;
+			}
+		}
+	}
+
+	/* stanumbers is an array of arrays of floats */
+	arraycont = key_lookup_array(cont, "stanumbers");
+	if (arraycont != NULL)
+	{
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			JsonbValue	   *j;
+			JsonbContainer *numarr;
+			int				nelems;
+			int				e;
+
+			j = getIthJsonbValueFromContainer(arraycont, k);
+
+			/* skip out-of-bounds and explicit nulls */
+			if (j == NULL)
+				continue;
+
+			if (j->type == jbvNull)
+			{
+				pfree(j);
+				continue;
+			}
+
+			if ((j->type != jbvBinary) ||
+				(!JsonContainerIsArray(j->val.binary.data)))
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stanumbers must be a binary array or null")));
+
+			numarr = j->val.binary.data;
+			pfree(j);
+
+			nelems = JsonContainerSize(numarr);
+			stats->numnumbers[k] = nelems;
+			stats->stanumbers[k] = (float4 *) palloc(nelems * sizeof(float4));
+
+			for (e = 0; e < nelems; e++)
+			{
+				JsonbValue *f = getIthJsonbValueFromContainer(numarr, e);
+				float4		floatval;
+				char	   *fstr;
+
+				/* skip out-of-bounds and explicit nulls */
+				if (f == NULL || f->type != jbvString)
+					ereport(ERROR,
+					  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					   errmsg("invalid statistics format, elements of stanumbers must a string")));
+
+				fstr = JsonbStringValueToCString(f);
+				floatval = float4in_internal(fstr, NULL, "realx3", fstr, NULL);
+				stats->stanumbers[k][e] = floatval;
+				pfree(f);
+				pfree(fstr);
+			}
+		}
+	}
+
+	/* stavalues is an array of arrays of the column attr type */
+	arraycont = key_lookup_array(cont, "stavalues");
+	if (arraycont != NULL)
+	{
+		Oid			in_func;
+		Oid			typioparam;
+		FmgrInfo	finfo;
+
+		getTypeInputInfo(stats->attrtypid, &in_func, &typioparam);
+		fmgr_info(in_func, &finfo);
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			JsonbValue	   *j;
+			JsonbContainer *attrarr;
+			int				nelems;
+			int				e;
+
+			j = getIthJsonbValueFromContainer(arraycont, k);
+
+			/* skip out-of-bounds and explicit nulls */
+			if (j == NULL)
+				continue;
+
+			if (j->type == jbvNull)
+			{
+				pfree(j);
+				continue;
+			}
+
+			if ((j->type != jbvBinary) ||
+				(!JsonContainerIsArray(j->val.binary.data)))
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stavalues must be a binary array or null")));
+
+			attrarr = j->val.binary.data;
+			pfree(j);
+			nelems = JsonContainerSize(attrarr);
+			stats->numvalues[k] = nelems;
+			stats->stavalues[k] = (Datum *) palloc(nelems * sizeof(Datum));
+
+			for (e = 0; e < nelems; e++)
+			{
+				JsonbValue *f;
+				char	   *fstr;
+				Datum		datum;
+
+				f = getIthJsonbValueFromContainer(attrarr, e);
+
+				/* skip out-of-bounds and explicit nulls */
+				if (f == NULL || f->type != jbvString)
+					ereport(ERROR,
+					  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					   errmsg("invalid statistics format, elements of stavalues must be a string")));
+
+				fstr = JsonbStringValueToCString(f);
+				datum = InputFunctionCall(&finfo, fstr, typioparam, stats->attrtypmod);
+				stats->stavalues[k][e] = datum;
+				pfree(fstr);
+				pfree(f);
+			}
+		}
+	}
+}
diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c
index edb2e5347d..f410510a28 100644
--- a/src/backend/statistics/dependencies.c
+++ b/src/backend/statistics/dependencies.c
@@ -27,7 +27,9 @@
 #include "parser/parsetree.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/bytea.h"
+#include "utils/float.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
@@ -1829,3 +1831,134 @@ dependencies_clauselist_selectivity(PlannerInfo *root,
 
 	return s1;
 }
+
+
+/*
+ * imports functional dependencies between groups of columns
+ *
+ * Generates all possible subsets of columns (variations) and computes
+ * the degree of validity for each one. For example when creating statistics
+ * on three columns (a,b,c) there are 9 possible dependencies
+ *
+ *	   two columns			  three columns
+ *	   -----------			  -------------
+ *	   (a) -> b				  (a,b) -> c
+ *	   (a) -> c				  (a,c) -> b
+ *	   (b) -> a				  (b,c) -> a
+ *	   (b) -> c
+ *	   (c) -> a
+ *	   (c) -> b
+ */
+MVDependencies *
+import_dependencies(JsonbContainer *cont)
+{
+	MVDependencies *dependencies = NULL;
+
+	int			numcombs;
+	int			i;
+
+	/* no dependencies to import */
+	if (cont == NULL)
+		return NULL;
+
+	/*
+	 *
+	 * format example:
+	 *
+	 * "stxdndependencies": <= you are here
+	 *   [
+	 *     {
+	 *       "attnums": [ "2", "-1" ],
+	 *       "degree": "0.500"
+	 *     },
+	 *     ...
+	 *   ]
+	 *
+	 */
+	numcombs = JsonContainerSize(cont);
+
+	/* no dependencies to import */
+	if (numcombs == 0)
+		return NULL;
+
+	dependencies = palloc(offsetof(MVDependencies, deps)
+							+ numcombs * sizeof(MVDependency *));
+
+	dependencies->magic = STATS_DEPS_MAGIC;
+	dependencies->type = STATS_DEPS_TYPE_BASIC;
+	dependencies->ndeps = numcombs;
+
+	for (i = 0; i < numcombs; i++)
+	{
+		MVDependency	   *d = dependencies->deps[i];
+		JsonbValue		   *elem;
+		JsonbContainer	   *dep;
+		JsonbValue		   *attnums;
+		JsonbContainer	   *attnumscont;
+		JsonbValue		   *degree;
+		char			   *degree_str;
+		int					numattnums;
+		int					j;
+
+		elem = getIthJsonbValueFromContainer(cont, i);
+
+		if ((elem->type != jbvBinary) ||
+			(!JsonContainerIsObject(elem->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxnddependencies elements must be binary objects")));
+
+		dep = elem->val.binary.data;
+		pfree(elem);
+
+		attnums = getKeyJsonValueFromContainer(dep, "attnums", strlen("attnums"), NULL);
+		if ((attnums == NULL) || (attnums->type != jbvBinary) ||
+			(!JsonContainerIsArray(attnums->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxndependencies must contain attnums array")));
+
+		attnumscont = attnums->val.binary.data;
+		pfree(attnums);
+		numattnums = JsonContainerSize(attnumscont);
+
+		d = palloc(offsetof(MVDependency, attributes)
+							+ numattnums * sizeof(AttrNumber));
+
+		d->nattributes = numattnums;
+
+		for (j = 0; j < numattnums; j++)
+		{
+			JsonbValue	   *attnum;
+			char		   *s;
+
+			attnum = getIthJsonbValueFromContainer(attnumscont, j);
+
+			if (attnum->type != jbvString)
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stxndependencies attnums elements must be strings")));
+
+			s = JsonbStringValueToCString(attnum);
+			pfree(attnum);
+
+			d->attributes[j] = pg_strtoint16(s);
+			pfree(s);
+		}
+
+		degree = getKeyJsonValueFromContainer(dep, "degree", strlen("degree"), NULL);
+		if ((degree == NULL) || (degree->type != jbvString))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxndependencies elements must have degree element")));
+
+		degree_str = JsonbStringValueToCString(degree);
+		pfree(degree);
+		d->degree = float8in_internal(degree_str, NULL, "double", degree_str, NULL);
+		pfree(degree_str);
+		dependencies->deps[i] = d;
+	}
+
+
+	return dependencies;
+}
diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index 9f67a57724..4e6e444f4c 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -2636,3 +2636,262 @@ make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
 
 	return result;
 }
+
+/* form an array of pg_statistic rows (per update_attstats) */
+static Datum
+serialize_vacattrstats(VacAttrStats **exprstats, int nexprs)
+{
+	int			exprno;
+	Oid			typOid;
+	Relation	sd;
+
+	ArrayBuildState *astate = NULL;
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/* lookup OID of composite type for pg_statistic */
+	typOid = get_rel_type_id(StatisticRelationId);
+	if (!OidIsValid(typOid))
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("relation \"%s\" does not have a composite type",
+						"pg_statistic")));
+
+	for (exprno = 0; exprno < nexprs; exprno++)
+	{
+		int			i,
+					k;
+		VacAttrStats *stats = exprstats[exprno];
+
+		Datum		values[Natts_pg_statistic];
+		bool		nulls[Natts_pg_statistic];
+		HeapTuple	stup;
+
+		if (!stats->stats_valid)
+		{
+			astate = accumArrayResult(astate,
+									  (Datum) 0,
+									  true,
+									  typOid,
+									  CurrentMemoryContext);
+			continue;
+		}
+
+		/*
+		 * Construct a new pg_statistic tuple
+		 */
+		for (i = 0; i < Natts_pg_statistic; ++i)
+		{
+			nulls[i] = false;
+		}
+
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
+		values[Anum_pg_statistic_stanullfrac - 1] = Float4GetDatum(stats->stanullfrac);
+		values[Anum_pg_statistic_stawidth - 1] = Int32GetDatum(stats->stawidth);
+		values[Anum_pg_statistic_stadistinct - 1] = Float4GetDatum(stats->stadistinct);
+		i = Anum_pg_statistic_stakind1 - 1;
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
+		}
+		i = Anum_pg_statistic_staop1 - 1;
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			values[i++] = ObjectIdGetDatum(stats->staop[k]);	/* staopN */
+		}
+		i = Anum_pg_statistic_stacoll1 - 1;
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			values[i++] = ObjectIdGetDatum(stats->stacoll[k]);	/* stacollN */
+		}
+		i = Anum_pg_statistic_stanumbers1 - 1;
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int			nnum = stats->numnumbers[k];
+
+			if (nnum > 0)
+			{
+				int			n;
+				Datum	   *numdatums = (Datum *) palloc(nnum * sizeof(Datum));
+				ArrayType  *arry;
+
+				for (n = 0; n < nnum; n++)
+					numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
+				arry = construct_array_builtin(numdatums, nnum, FLOAT4OID);
+				values[i++] = PointerGetDatum(arry);	/* stanumbersN */
+			}
+			else
+			{
+				nulls[i] = true;
+				values[i++] = (Datum) 0;
+			}
+		}
+		i = Anum_pg_statistic_stavalues1 - 1;
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			if (stats->numvalues[k] > 0)
+			{
+				ArrayType  *arry;
+
+				arry = construct_array(stats->stavalues[k],
+									   stats->numvalues[k],
+									   stats->statypid[k],
+									   stats->statyplen[k],
+									   stats->statypbyval[k],
+									   stats->statypalign[k]);
+				values[i++] = PointerGetDatum(arry);	/* stavaluesN */
+			}
+			else
+			{
+				nulls[i] = true;
+				values[i++] = (Datum) 0;
+			}
+		}
+
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+
+		astate = accumArrayResult(astate,
+								  heap_copy_tuple_as_datum(stup, RelationGetDescr(sd)),
+								  false,
+								  typOid,
+								  CurrentMemoryContext);
+	}
+
+	table_close(sd, RowExclusiveLock);
+
+	return makeArrayResult(astate, CurrentMemoryContext);
+}
+
+/*
+ * Import requested extended stats, using the pre-computed (single-column)
+ * stats.
+ *
+ * This fetches a list of stats types from pg_statistic_ext, extracts the
+ * requested stats from the jsonb, and serializes them back into the catalog.
+ */
+void
+ImportRelationExtStatistics(Relation onerel, bool inh,
+						   int natts,
+						   VacAttrStats **vacattrstats,
+						   JsonbContainer *cont)
+{
+	Relation	pg_stext;
+	ListCell   *lc;
+	List	   *statslist;
+
+	/* Do nothing if there are no columns to analyze. */
+	if (!natts)
+		return;
+
+	/* Do nothing if there are no stats to import */
+	if (cont == NULL)
+		return;
+
+	/* the list of stats has to be allocated outside the memory context */
+	pg_stext = table_open(StatisticExtRelationId, RowExclusiveLock);
+	statslist = fetch_statentries_for_relation(pg_stext, RelationGetRelid(onerel));
+
+	/*
+	 * format:
+	 *
+	 * { <= you are here
+	 *   <stat-name>:
+	 *     {
+	 *        "stxkinds": array of single characters (up to 3?),
+	 *        "stxdndistinct": [ {ndistinct}, ... ],
+	 *        "stxdndependencies": [ {dependency}, ... ]
+	 *        "stxdmcv": [ {mcv}, ... ]
+	 *        "stxdexprs" : [ {pg_statistic}, ... ]
+	 *     },
+	 *     ...
+	 * }
+	 */
+
+	foreach(lc, statslist)
+	{
+		StatExtEntry *stat = (StatExtEntry *) lfirst(lc);
+		MVNDistinct *ndistinct = NULL;
+		MVDependencies *dependencies = NULL;
+		MCVList    *mcv = NULL;
+		Datum		exprstats = (Datum) 0;
+		VacAttrStats **stats;
+		JsonbValue	   *exprval;
+		JsonbContainer *attrcont,
+					   *ndistcont,
+					   *depcont,
+					   *exprcont;
+
+		/*
+		 * Check if we can build these stats based on the column analyzed. If
+		 * not, report this fact (except in autovacuum) and move on.
+		 */
+		stats = lookup_var_attr_stats(onerel, stat->columns, stat->exprs,
+									  natts, vacattrstats);
+		if (!stats)
+			continue;
+
+		attrcont = key_lookup_object(cont, stat->name);
+
+		/* staname not found, skip */
+		if (attrcont == NULL)
+			continue;
+
+		ndistcont = key_lookup_array(attrcont, "stxdndistinct");
+
+		if (ndistcont != NULL)
+			ndistinct = import_ndistinct(ndistcont);
+
+		depcont = key_lookup_array(attrcont, "stxdndependencies");
+		if (depcont != NULL)
+			dependencies = import_dependencies(depcont);
+
+		/* TODO mcvcont for "stxdmcv" and import_mcv() */
+
+		exprval = getKeyJsonValueFromContainer(attrcont, "stxdexprs", strlen("stxdexprs"), NULL);
+		if (exprval != NULL)
+		{
+			if (exprval->type != jbvNull)
+			{
+				int	nexprs;
+				int	k;
+
+				if (!JsonContainerIsArray(exprval->val.binary.data))
+			   		errmsg("invalid statistics format, stxndeprs must be array or null");
+
+				exprcont = exprval->val.binary.data;
+
+				nexprs = JsonContainerSize(exprcont);
+
+				for (k = 0; k < nexprs; k++)
+				{
+					JsonbValue *statelem;
+
+					statelem = getIthJsonbValueFromContainer(exprcont, k);
+					if ((statelem->type != jbvBinary) ||
+						(!JsonContainerIsObject(statelem->val.binary.data)))
+						ereport(ERROR,
+						  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						   errmsg("invalid statistics format, stxdexprs elements must be binary objects")));
+
+					ImportVacAttrStats(stats[k], statelem->val.binary.data);
+					pfree(statelem);
+				}
+
+				exprstats = serialize_vacattrstats(stats, nexprs);
+
+			}
+			pfree(exprval);
+		}
+
+
+		/* store the statistics in the catalog */
+		statext_store(stat->statOid, inh,
+					  ndistinct, dependencies, mcv, exprstats, stats);
+	}
+
+	list_free(statslist);
+
+	table_close(pg_stext, RowExclusiveLock);
+}
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index 03b9f04bb5..8fbb388028 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -2177,3 +2177,9 @@ mcv_clause_selectivity_or(PlannerInfo *root, StatisticExtInfo *stat,
 
 	return s;
 }
+
+MCVList *import_mcv(JsonbContainer *cont)
+{
+	return NULL;
+}
+
diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c
index 6d25c14644..8489a758a6 100644
--- a/src/backend/statistics/mvdistinct.c
+++ b/src/backend/statistics/mvdistinct.c
@@ -31,6 +31,8 @@
 #include "lib/stringinfo.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -698,3 +700,121 @@ generate_combinations(CombinationGenerator *state)
 
 	pfree(current);
 }
+
+
+/*
+ * Import ndistinct values from JsonB.
+ *
+ * To handle expressions easily, we treat them as system attributes with
+ * negative attnums, and offset everything by number of expressions to
+ * allow using Bitmapsets.
+ */
+MVNDistinct *
+import_ndistinct(JsonbContainer *cont)
+{
+	MVNDistinct *result;
+	int			numcombs;
+	int			i;
+
+	/* no ndistinct to import */
+	if (cont == NULL)
+		return NULL;
+
+	/* each row of the JSON is a combination */
+	numcombs = JsonContainerSize(cont);
+
+	/* no ndistinct to import */
+	if (numcombs == 0)
+		return NULL;
+
+	result = palloc(offsetof(MVNDistinct, items) +
+					numcombs * sizeof(MVNDistinctItem));
+	result->magic = STATS_NDISTINCT_MAGIC;
+	result->type = STATS_NDISTINCT_TYPE_BASIC;
+	result->nitems = numcombs;
+
+	/*
+	 * format example:
+	 *
+	 * "stxdndistinct": [
+	 *     {
+	 *       "attnums": [ "2", "1" ],
+	 *       "ndistinct": "4"
+	 *     },
+	 *     ...
+	 *   ]
+	 *
+	 */
+	for (i = 0; i < numcombs; i++)
+	{
+		MVNDistinctItem	   *item;
+		JsonbValue		   *elem;
+		JsonbContainer	   *combo;
+		JsonbValue		   *attnums;
+		JsonbContainer	   *attnumscont;
+		JsonbValue		   *ndistinct;
+		char			   *ndist_str;
+		int					numattnums;
+		int					j;
+
+		item = &result->items[i];
+
+		elem = getIthJsonbValueFromContainer(cont, i);
+
+		if ((elem->type != jbvBinary) ||
+			(!JsonContainerIsObject(elem->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxndistinct elements must be a binary objects")));
+
+		combo = elem->val.binary.data;
+
+		attnums = getKeyJsonValueFromContainer(combo, "attnums", strlen("attnums"), NULL);
+		if ((attnums == NULL) || (attnums->type != jbvBinary) ||
+			(!JsonContainerIsArray(attnums->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxndistinct must contain attnums array")));
+
+		attnumscont = attnums->val.binary.data;
+		numattnums = JsonContainerSize(attnumscont);
+
+		item->attributes = palloc(sizeof(AttrNumber) * numattnums);
+		item->nattributes = numattnums;
+
+		for (j = 0; j < numattnums; j++)
+		{
+			JsonbValue	   *attnum;
+			char		   *s;
+			attnum = getIthJsonbValueFromContainer(attnumscont, j);
+
+			if (attnum->type != jbvString)
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stxndistinct attnums elements must be strings, but one is %s", 
+						  JsonbTypeName(attnum))));
+
+			s = JsonbStringValueToCString(attnum);
+
+			item->attributes[j] = pg_strtoint16(s);
+			pfree(s);
+			pfree(attnum);
+		}
+
+		ndistinct = getKeyJsonValueFromContainer(combo, "ndistinct", strlen("ndistinct"), NULL);
+		if ((ndistinct == NULL) || (ndistinct->type != jbvString))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, stxndistinct elements must have ndistinct element")));
+
+		ndist_str = JsonbStringValueToCString(ndistinct);
+		item->ndistinct = float8in_internal(ndist_str, NULL, "double", ndist_str, NULL);
+
+		pfree(ndist_str);
+		pfree(ndistinct);
+		pfree(attnums);
+		pfree(elem);
+	}
+
+	return result;
+}
diff --git a/src/test/regress/expected/vacuum.out b/src/test/regress/expected/vacuum.out
index 4def90b805..4e609ca3b6 100644
--- a/src/test/regress/expected/vacuum.out
+++ b/src/test/regress/expected/vacuum.out
@@ -508,3 +508,156 @@ RESET ROLE;
 DROP TABLE vacowned;
 DROP TABLE vacowned_parted;
 DROP ROLE regress_vacuum;
+CREATE TYPE stats_import_complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_import_test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_import_complex_type
+);
+INSERT INTO stats_import_test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_import_complex_type
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_import_complex_type
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_import_complex_type
+UNION ALL
+SELECT 4, 'four', NULL;
+CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
+CREATE STATISTICS oddness ON name, ((comp).a % 2 = 1) FROM stats_import_test;
+ANALYZE stats_import_test;
+CREATE TABLE stats_export AS
+SELECT e.*
+FROM pg_catalog.pg_statistic_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname = 'stats_import_test';
+SELECT c.reltuples AS before_tuples, c.relpages AS before_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ before_tuples | before_pages 
+---------------+--------------
+             4 |            1
+(1 row)
+
+-- test settting tuples and pages but no columns
+SELECT pg_import_rel_stats(c.oid, current_setting('server_version_num')::integer,
+                           1000.0, 200, NULL::jsonb)
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+SELECT c.reltuples AS after_tuples, c.relpages AS after_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ after_tuples | after_pages 
+--------------+-------------
+         1000 |         200
+(1 row)
+
+CREATE TEMPORARY TABLE orig_stats
+AS
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass;
+CREATE TEMPORARY TABLE orig_export
+AS
+SELECT e.*
+FROM stats_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname = 'stats_import_test';
+-- create a table just like stats_import_test
+CREATE TABLE stats_import_clone ( LIKE stats_import_test );
+-- create an index that does not exist on stats_import_test
+CREATE INDEX is_even ON stats_import_clone(((comp).a % 2 = 0));
+-- rename statistics object to allow for a same-named one on the clone
+ALTER STATISTICS oddness RENAME TO oddness_original;
+CREATE STATISTICS oddness ON name, ((comp).a % 2 = 1) FROM stats_import_clone;
+-- copy table stats to clone table
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN orig_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'stats_import_test'
+WHERE c.oid = 'stats_import_clone'::regclass;
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- stats should match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_clone'::regclass;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+-- compare all except stxdmcv and oid-related stxdexprs
+SELECT d.stxdinherit, d.stxdndistinct, d.stxddependencies, xpr.xpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+LEFT JOIN LATERAL (
+    SELECT
+        array_agg(ROW(x.staattnum, x.stainherit, x.stanullfrac, x.stawidth,
+                      x.stadistinct, x.stakind1, x.stakind2, x.stakind3,
+                      x.stakind4, x.stakind5, x.stanumbers1, x.stanumbers2,
+                      x.stanumbers3, x.stanumbers4, x.stanumbers5, x.stavalues1,
+                      x.stavalues2, x.stavalues3, x.stavalues4, x.stavalues5
+                      )::text ORDER BY x.ordinality)
+    FROM unnest(d.stxdexpr) WITH ORDINALITY AS x
+) AS xpr(xpr) ON d.stxdexpr IS NOT NULL
+WHERE e.stxrelid = 'stats_import_test'::regclass
+AND e.stxname = 'oddness_original'
+EXCEPT
+SELECT d.stxdinherit, d.stxdndistinct, d.stxddependencies, xpr.xpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+LEFT JOIN LATERAL (
+    SELECT
+        array_agg(ROW(x.staattnum, x.stainherit, x.stanullfrac, x.stawidth,
+                      x.stadistinct, x.stakind1, x.stakind2, x.stakind3,
+                      x.stakind4, x.stakind5, x.stanumbers1, x.stanumbers2,
+                      x.stanumbers3, x.stanumbers4, x.stanumbers5, x.stavalues1,
+                      x.stavalues2, x.stavalues3, x.stavalues4, x.stavalues5
+                      )::text ORDER BY x.ordinality)
+    FROM unnest(d.stxdexpr) WITH ORDINALITY AS x
+) AS xpr(xpr) ON d.stxdexpr IS NOT NULL
+WHERE e.stxrelid = 'stats_import_clone'::regclass
+AND e.stxname = 'oddness';
+ stxdinherit | stxdndistinct | stxddependencies | xpr 
+-------------+---------------+------------------+-----
+(0 rows)
+
+DROP TABLE stats_export;
+DROP TABLE stats_import_clone;
+DROP TABLE stats_import_test;
+DROP TYPE stats_import_complex_type;
diff --git a/src/test/regress/sql/vacuum.sql b/src/test/regress/sql/vacuum.sql
index 51d7b1fecc..b42f35a8e3 100644
--- a/src/test/regress/sql/vacuum.sql
+++ b/src/test/regress/sql/vacuum.sql
@@ -377,3 +377,149 @@ RESET ROLE;
 DROP TABLE vacowned;
 DROP TABLE vacowned_parted;
 DROP ROLE regress_vacuum;
+
+
+CREATE TYPE stats_import_complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_import_test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_import_complex_type
+);
+
+INSERT INTO stats_import_test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_import_complex_type
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_import_complex_type
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_import_complex_type
+UNION ALL
+SELECT 4, 'four', NULL;
+
+CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
+
+CREATE STATISTICS oddness ON name, ((comp).a % 2 = 1) FROM stats_import_test;
+
+ANALYZE stats_import_test;
+
+CREATE TABLE stats_export AS
+SELECT e.*
+FROM pg_catalog.pg_statistic_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname = 'stats_import_test';
+
+SELECT c.reltuples AS before_tuples, c.relpages AS before_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+-- test settting tuples and pages but no columns
+SELECT pg_import_rel_stats(c.oid, current_setting('server_version_num')::integer,
+                           1000.0, 200, NULL::jsonb)
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+SELECT c.reltuples AS after_tuples, c.relpages AS after_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+CREATE TEMPORARY TABLE orig_stats
+AS
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass;
+
+CREATE TEMPORARY TABLE orig_export
+AS
+SELECT e.*
+FROM stats_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname = 'stats_import_test';
+
+-- create a table just like stats_import_test
+CREATE TABLE stats_import_clone ( LIKE stats_import_test );
+
+-- create an index that does not exist on stats_import_test
+CREATE INDEX is_even ON stats_import_clone(((comp).a % 2 = 0));
+
+-- rename statistics object to allow for a same-named one on the clone
+ALTER STATISTICS oddness RENAME TO oddness_original;
+
+CREATE STATISTICS oddness ON name, ((comp).a % 2 = 1) FROM stats_import_clone;
+
+-- copy table stats to clone table
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN orig_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'stats_import_test'
+WHERE c.oid = 'stats_import_clone'::regclass;
+
+-- stats should match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_clone'::regclass;
+
+-- compare all except stxdmcv and oid-related stxdexprs
+SELECT d.stxdinherit, d.stxdndistinct, d.stxddependencies, xpr.xpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+LEFT JOIN LATERAL (
+    SELECT
+        array_agg(ROW(x.staattnum, x.stainherit, x.stanullfrac, x.stawidth,
+                      x.stadistinct, x.stakind1, x.stakind2, x.stakind3,
+                      x.stakind4, x.stakind5, x.stanumbers1, x.stanumbers2,
+                      x.stanumbers3, x.stanumbers4, x.stanumbers5, x.stavalues1,
+                      x.stavalues2, x.stavalues3, x.stavalues4, x.stavalues5
+                      )::text ORDER BY x.ordinality)
+    FROM unnest(d.stxdexpr) WITH ORDINALITY AS x
+) AS xpr(xpr) ON d.stxdexpr IS NOT NULL
+WHERE e.stxrelid = 'stats_import_test'::regclass
+AND e.stxname = 'oddness_original'
+EXCEPT
+SELECT d.stxdinherit, d.stxdndistinct, d.stxddependencies, xpr.xpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+LEFT JOIN LATERAL (
+    SELECT
+        array_agg(ROW(x.staattnum, x.stainherit, x.stanullfrac, x.stawidth,
+                      x.stadistinct, x.stakind1, x.stakind2, x.stakind3,
+                      x.stakind4, x.stakind5, x.stanumbers1, x.stanumbers2,
+                      x.stanumbers3, x.stanumbers4, x.stanumbers5, x.stavalues1,
+                      x.stavalues2, x.stavalues3, x.stavalues4, x.stavalues5
+                      )::text ORDER BY x.ordinality)
+    FROM unnest(d.stxdexpr) WITH ORDINALITY AS x
+) AS xpr(xpr) ON d.stxdexpr IS NOT NULL
+WHERE e.stxrelid = 'stats_import_clone'::regclass
+AND e.stxname = 'oddness';
+
+DROP TABLE stats_export;
+DROP TABLE stats_import_clone;
+DROP TABLE stats_import_test;
+DROP TYPE stats_import_complex_type;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index c76ec52c55..61e01d1b90 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28014,6 +28014,48 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_rel_stats</primary>
+        </indexterm>
+        <function>pg_import_rel_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>server_version_num</parameter> <type>integer</type>, <parameter>num_tuples</parameter> <type>float4</type>, <parameter>num_pages</parameter> <type>integer</type>, <parameter>column_stats</parameter> <type>jsonb</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_class</structname> row with the
+        <structfield>oid</structfield> matching <parameter>relation</parameter>
+        to set the <structfield>reltuples</structfield> and
+        <structfield>relpages</structfield> fields. This is done nontransactionally.
+        The <structname>pg_statistic</structname> rows for the
+        <structfield>statrelid</structfield> matching <parameter>relation</parameter>
+        are replaced with the values found in <parameter>column_stats</parameter>,
+        and this is done transactionally. The purpose of this function is to apply
+        statistics values in an upgrade situation that are "good enough" for system
+        operation until they are replaced by the next auto-analyze. This function
+        is used by <program>pg_upgrade</program> and <program>pg_restore</program>
+        to convey the statistics from the old system version into the new one.
+       </para></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.41.0

From da9b9a4012757a8bb08711d4479ce5ebb38e974d Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 31 Oct 2023 03:13:24 -0400
Subject: [PATCH v2 4/4] Add pg_export_stats, pg_import_stats.

pg_export_stats is used to export stats from databases as far back as
v10. The output is currently only to stdout and should be redirected to
a file in most use cases.

pg_import_stats is used to import stats to any version that has the
function pg_import_rel_stats().
---
 src/bin/scripts/Makefile          |   6 +-
 src/bin/scripts/pg_export_stats.c | 946 ++++++++++++++++++++++++++++++
 src/bin/scripts/pg_import_stats.c | 303 ++++++++++
 3 files changed, 1254 insertions(+), 1 deletion(-)
 create mode 100644 src/bin/scripts/pg_export_stats.c
 create mode 100644 src/bin/scripts/pg_import_stats.c

diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile
index a7a9d0fea5..da45fcfa6a 100644
--- a/src/bin/scripts/Makefile
+++ b/src/bin/scripts/Makefile
@@ -16,7 +16,7 @@ subdir = src/bin/scripts
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready
+PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready pg_export_stats pg_import_stats
 
 override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
 LDFLAGS_INTERNAL += -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport)
@@ -31,6 +31,8 @@ clusterdb: clusterdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport su
 vacuumdb: vacuumdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 reindexdb: reindexdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 pg_isready: pg_isready.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
+pg_export_stats: pg_export_stats.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
+pg_import_stats: pg_import_stats.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 
 install: all installdirs
 	$(INSTALL_PROGRAM) createdb$(X)   '$(DESTDIR)$(bindir)'/createdb$(X)
@@ -41,6 +43,8 @@ install: all installdirs
 	$(INSTALL_PROGRAM) vacuumdb$(X)   '$(DESTDIR)$(bindir)'/vacuumdb$(X)
 	$(INSTALL_PROGRAM) reindexdb$(X)  '$(DESTDIR)$(bindir)'/reindexdb$(X)
 	$(INSTALL_PROGRAM) pg_isready$(X) '$(DESTDIR)$(bindir)'/pg_isready$(X)
+	$(INSTALL_PROGRAM) pg_export_stats$(X) '$(DESTDIR)$(bindir)'/pg_export_stats$(X)
+	$(INSTALL_PROGRAM) pg_import_stats$(X) '$(DESTDIR)$(bindir)'/pg_import_stats$(X)
 
 installdirs:
 	$(MKDIR_P) '$(DESTDIR)$(bindir)'
diff --git a/src/bin/scripts/pg_export_stats.c b/src/bin/scripts/pg_export_stats.c
new file mode 100644
index 0000000000..b9fc192e8f
--- /dev/null
+++ b/src/bin/scripts/pg_export_stats.c
@@ -0,0 +1,946 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_export_stats
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_export_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+static void help(const char *progname);
+
+/* view definition introduced in 17 */
+const char *export_query_v17 =
+	"SELECT schemaname, relname, server_version_num, n_tuples, "
+	"n_pages, stats FROM pg_statistic_export ";
+
+/* v15-v16 have the same stats layout, but lacks view definition */
+const char *export_query_v15 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    r.reltuples::float4 AS n_tuples, "
+	"    r.relpages::integer AS n_pages, "
+	"    ( "
+	"        WITH per_column_stats AS "
+	"        ( "
+	"            SELECT "
+	"                s.stainherit, "
+	"                a.attname, "
+	"                jsonb_build_object( "
+	"                    'stanullfrac', s.stanullfrac::text, "
+	"                    'stawidth', s.stawidth::text, "
+	"                    'stadistinct', s.stadistinct::text, "
+	"                    'stakinds', "
+	"                    ( "
+	"                        SELECT "
+	"                            jsonb_agg( "
+	"                                CASE kind.kind "
+	"                                    WHEN 0 THEN 'TRIVIAL' "
+	"                                    WHEN 1 THEN 'MCV' "
+	"                                    WHEN 2 THEN 'HISTOGRAM' "
+	"                                    WHEN 3 THEN 'CORRELATION' "
+	"                                    WHEN 4 THEN 'MCELEM' "
+	"                                    WHEN 5 THEN 'DECHIST' "
+	"                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                END::text "
+	"                                ORDER BY kind.ord) "
+	"                        FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                    s.stakind3, stakind4, "
+	"                                    s.stakind5]) "
+	"                             WITH ORDINALITY AS kind(kind, ord) "
+	"                    ), "
+	"                    'stanumbers', "
+	"                    jsonb_build_array( "
+	"                        s.stanumbers1::text::text[], "
+	"                        s.stanumbers2::text::text[], "
+	"                        s.stanumbers3::text::text[], "
+	"                        s.stanumbers4::text::text[], "
+	"                        s.stanumbers5::text::text[]), "
+	"                    'stavalues', "
+	"                    jsonb_build_array( "
+	"                        s.stavalues1::text::text[], "
+	"                        s.stavalues2::text::text[], "
+	"                        s.stavalues3::text::text[], "
+	"                        s.stavalues4::text::text[], "
+	"                        s.stavalues5::text::text[]) "
+	"                ) AS stats "
+	"            FROM pg_attribute AS a "
+	"            JOIN pg_statistic AS s "
+	"                ON s.starelid = a.attrelid "
+	"                AND s.staattnum = a.attnum "
+	"            WHERE a.attrelid = r.oid "
+	"            AND NOT a.attisdropped "
+	"            AND a.attnum > 0 "
+	"            AND has_column_privilege(a.attrelid, a.attnum, 'SELECT') "
+	"        ), "
+	"        attagg AS "
+	"        ( "
+	"            SELECT "
+	"                pcs.stainherit, "
+	"                jsonb_build_object( "
+	"                    'columns', "
+	"                    jsonb_object_agg( "
+	"                        pcs.attname, "
+	"                        pcs.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM per_column_stats AS pcs "
+	"            GROUP BY pcs.stainherit "
+	"        ), "
+	"        extended_object_stats AS "
+	"        ( "
+	"            SELECT "
+	"                sd.stxdinherit, "
+	"                e.stxname, "
+	"                jsonb_build_object( "
+	"                    'stxkinds', "
+	"                    to_jsonb(e.stxkind), "
+	"                    'stxdndistinct', "
+	"                    ndist.stxdndistinct, "
+	"                    'stxdndependencies', "
+	"                    ndep.stxdndependencies, "
+	"                    'stxdmcv', "
+	"                    mcv.stxdmcv, "
+	"                    'stxdexprs', "
+	"                    x.stdxdexprs "
+	"                ) AS stats "
+	"            FROM pg_statistic_ext AS e "
+	"            JOIN pg_statistic_ext_data AS sd "
+	"                ON sd.stxoid = e.oid "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', string_to_array(nd.attnums, ', '), "
+	"                                'ndistinct', nd.ndistinct "
+	"                                ) "
+	"                            ORDER BY nd.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                         WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                ) AS ndist(stxdndistinct) ON sd.stxdndistinct IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', "
+	"                                string_to_array( replace(dep.attrs, ' => ', ', '), ', '), "
+	"                                'degree', "
+	"                                dep.degree "
+	"                                ) "
+	"                            ORDER BY dep.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxddependencies::text::json) "
+	"                         WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                ) AS ndep(stxdndependencies) ON sd.stxddependencies IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT NULL AS stxdmcv "
+	"                ) AS mcv(stxdmcv) ON sd.stxdmcv IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'stanullfrac', s.stanullfrac::text, "
+	"                                'stawidth', s.stawidth::text, "
+	"                                'stadistinct', s.stadistinct::text, "
+	"                                'stakinds', "
+	"                                ( "
+	"                                    SELECT "
+	"                                        jsonb_agg( "
+	"                                            CASE kind.kind "
+	"                                                WHEN 0 THEN 'TRIVIAL' "
+	"                                                WHEN 1 THEN 'MCV' "
+	"                                                WHEN 2 THEN 'HISTOGRAM' "
+	"                                                WHEN 3 THEN 'CORRELATION' "
+	"                                                WHEN 4 THEN 'MCELEM' "
+	"                                                WHEN 5 THEN 'DECHIST' "
+	"                                                WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                                WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                            END::text "
+	"                                            ORDER BY kind.ord) "
+	"                                    FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                                s.stakind3, stakind4, "
+	"                                                s.stakind5]) WITH ORDINALITY AS kind(kind, ord) "
+	"                                ), "
+	"                                'stanumbers', "
+	"                                jsonb_build_array( "
+	"                                    s.stanumbers1::text::text[], "
+	"                                    s.stanumbers2::text::text[], "
+	"                                    s.stanumbers3::text::text[], "
+	"                                    s.stanumbers4::text::text[], "
+	"                                    s.stanumbers5::text::text[]), "
+	"                                'stavalues', "
+	"                                jsonb_build_array( "
+	"                                    s.stavalues1::text::text[], "
+	"                                    s.stavalues2::text::text[], "
+	"                                    s.stavalues3::text::text[], "
+	"                                    s.stavalues4::text::text[], "
+	"                                    s.stavalues5::text::text[]) "
+	"                            ) "
+	"                            ORDER BY s.ordinality "
+	"                        ) "
+	"                    FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s "
+	"                ) AS x(stdxdexprs) ON sd.stxdexpr IS NOT NULL "
+	"            WHERE e.stxrelid = r.oid "
+	"        ), "
+	"        extagg AS "
+	"        ( "
+	"            SELECT "
+	"                eos.stxdinherit, "
+	"                jsonb_build_object( "
+	"                    'extended', "
+	"                    jsonb_object_agg( "
+	"                        eos.stxname, "
+	"                        eos.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM extended_object_stats AS eos "
+	"            GROUP BY eos.stxdinherit "
+	"        ) "
+	"        SELECT "
+	"            jsonb_object_agg( "
+	"                CASE coalesce(a.stainherit, e.stxdinherit) "
+	"                    WHEN TRUE THEN 'inherited' "
+	"                    ELSE 'regular' "
+	"                END, "
+	"                coalesce(a.stats, '{}'::jsonb) || coalesce(e.stats, '{}'::jsonb)  "
+	"            ) "
+	"        FROM attagg AS a "
+	"        FULL OUTER JOIN extagg e ON a.stainherit = e.stxdinherit "
+	"    ) AS stats "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n "
+	"    ON n.oid = r.relnamespace "
+	"WHERE relkind IN ('r', 'm', 'f', 'p') "
+	"AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
+
+/* v14 is like v15, but lacks stxdinherit on ext_data */
+const char *export_query_v14 = 
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    r.reltuples::float4 AS n_tuples, "
+	"    r.relpages::integer AS n_pages, "
+	"    ( "
+	"        WITH per_column_stats AS "
+	"        ( "
+	"            SELECT "
+	"                s.stainherit, "
+	"                a.attname, "
+	"                jsonb_build_object( "
+	"                    'stanullfrac', s.stanullfrac::text, "
+	"                    'stawidth', s.stawidth::text, "
+	"                    'stadistinct', s.stadistinct::text, "
+	"                    'stakinds', "
+	"                    ( "
+	"                        SELECT "
+	"                            jsonb_agg( "
+	"                                CASE kind.kind "
+	"                                    WHEN 0 THEN 'TRIVIAL' "
+	"                                    WHEN 1 THEN 'MCV' "
+	"                                    WHEN 2 THEN 'HISTOGRAM' "
+	"                                    WHEN 3 THEN 'CORRELATION' "
+	"                                    WHEN 4 THEN 'MCELEM' "
+	"                                    WHEN 5 THEN 'DECHIST' "
+	"                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                END::text "
+	"                                ORDER BY kind.ord) "
+	"                        FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                    s.stakind3, stakind4, "
+	"                                    s.stakind5]) "
+	"                             WITH ORDINALITY AS kind(kind, ord) "
+	"                    ), "
+	"                    'stanumbers', "
+	"                    jsonb_build_array( "
+	"                        s.stanumbers1::text::text[], "
+	"                        s.stanumbers2::text::text[], "
+	"                        s.stanumbers3::text::text[], "
+	"                        s.stanumbers4::text::text[], "
+	"                        s.stanumbers5::text::text[]), "
+	"                    'stavalues', "
+	"                    jsonb_build_array( "
+	"                        s.stavalues1::text::text[], "
+	"                        s.stavalues2::text::text[], "
+	"                        s.stavalues3::text::text[], "
+	"                        s.stavalues4::text::text[], "
+	"                        s.stavalues5::text::text[]) "
+	"                ) AS stats "
+	"            FROM pg_attribute AS a "
+	"            JOIN pg_statistic AS s "
+	"                ON s.starelid = a.attrelid "
+	"                AND s.staattnum = a.attnum "
+	"            WHERE a.attrelid = r.oid "
+	"            AND NOT a.attisdropped "
+	"            AND a.attnum > 0 "
+	"            AND has_column_privilege(a.attrelid, a.attnum, 'SELECT') "
+	"        ), "
+	"        attagg AS "
+	"        ( "
+	"            SELECT "
+	"                pcs.stainherit, "
+	"                jsonb_build_object( "
+	"                    'columns', "
+	"                    jsonb_object_agg( "
+	"                        pcs.attname, "
+	"                        pcs.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM per_column_stats AS pcs "
+	"            GROUP BY pcs.stainherit "
+	"        ), "
+	"        extended_object_stats AS "
+	"        ( "
+	"            SELECT "
+	"                false AS stxdinherit, "
+	"                e.stxname, "
+	"                jsonb_build_object( "
+	"                    'stxkinds', "
+	"                    to_jsonb(e.stxkind), "
+	"                    'stxdndistinct', "
+	"                    ndist.stxdndistinct, "
+	"                    'stxdndependencies', "
+	"                    ndep.stxdndependencies, "
+	"                    'stxdmcv', "
+	"                    mcv.stxdmcv, "
+	"                    'stxdexprs', "
+	"                    x.stdxdexprs "
+	"                ) AS stats "
+	"            FROM pg_statistic_ext AS e "
+	"            JOIN pg_statistic_ext_data AS sd "
+	"                ON sd.stxoid = e.oid "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', string_to_array(nd.attnums, ', '), "
+	"                                'ndistinct', nd.ndistinct "
+	"                                ) "
+	"                            ORDER BY nd.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                         WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                ) AS ndist(stxdndistinct) ON sd.stxdndistinct IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', "
+	"                                string_to_array( replace(dep.attrs, ' => ', ', '), ', '), "
+	"                                'degree', "
+	"                                dep.degree "
+	"                                ) "
+	"                            ORDER BY dep.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxddependencies::text::json) "
+	"                         WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                ) AS ndep(stxdndependencies) ON sd.stxddependencies IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT NULL AS stxdmcv "
+	"                ) AS mcv(stxdmcv) ON sd.stxdmcv IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'stanullfrac', s.stanullfrac::text, "
+	"                                'stawidth', s.stawidth::text, "
+	"                                'stadistinct', s.stadistinct::text, "
+	"                                'stakinds', "
+	"                                ( "
+	"                                    SELECT "
+	"                                        jsonb_agg( "
+	"                                            CASE kind.kind "
+	"                                                WHEN 0 THEN 'TRIVIAL' "
+	"                                                WHEN 1 THEN 'MCV' "
+	"                                                WHEN 2 THEN 'HISTOGRAM' "
+	"                                                WHEN 3 THEN 'CORRELATION' "
+	"                                                WHEN 4 THEN 'MCELEM' "
+	"                                                WHEN 5 THEN 'DECHIST' "
+	"                                                WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                                WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                            END::text "
+	"                                            ORDER BY kind.ord) "
+	"                                    FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                                s.stakind3, stakind4, "
+	"                                                s.stakind5]) WITH ORDINALITY AS kind(kind, ord) "
+	"                                ), "
+	"                                'stanumbers', "
+	"                                jsonb_build_array( "
+	"                                    s.stanumbers1::text::text[], "
+	"                                    s.stanumbers2::text::text[], "
+	"                                    s.stanumbers3::text::text[], "
+	"                                    s.stanumbers4::text::text[], "
+	"                                    s.stanumbers5::text::text[]), "
+	"                                'stavalues', "
+	"                                jsonb_build_array( "
+	"                                    s.stavalues1::text::text[], "
+	"                                    s.stavalues2::text::text[], "
+	"                                    s.stavalues3::text::text[], "
+	"                                    s.stavalues4::text::text[], "
+	"                                    s.stavalues5::text::text[]) "
+	"                            ) "
+	"                            ORDER BY s.ordinality "
+	"                        ) "
+	"                    FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s "
+	"                ) AS x(stdxdexprs) ON sd.stxdexpr IS NOT NULL "
+	"            WHERE e.stxrelid = r.oid "
+	"        ), "
+	"        extagg AS "
+	"        ( "
+	"            SELECT "
+	"                eos.stxdinherit, "
+	"                jsonb_build_object( "
+	"                    'extended', "
+	"                    jsonb_object_agg( "
+	"                        eos.stxname, "
+	"                        eos.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM extended_object_stats AS eos "
+	"            GROUP BY eos.stxdinherit "
+	"        ) "
+	"        SELECT "
+	"            jsonb_object_agg( "
+	"                CASE coalesce(a.stainherit, e.stxdinherit) "
+	"                    WHEN TRUE THEN 'inherited' "
+	"                    ELSE 'regular' "
+	"                END, "
+	"                coalesce(a.stats, '{}'::jsonb) || coalesce(e.stats, '{}'::jsonb)  "
+	"            ) "
+	"        FROM attagg AS a "
+	"        FULL OUTER JOIN extagg e ON a.stainherit = e.stxdinherit "
+	"    ) AS stats "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n "
+	"    ON n.oid = r.relnamespace "
+	"WHERE relkind IN ('r', 'm', 'f', 'p') "
+	"AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
+
+/* v12-v13 are like v14, but lacks stxdexpr on ext_data */
+const char *export_query_v12 = 
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    r.reltuples::float4 AS n_tuples, "
+	"    r.relpages::integer AS n_pages, "
+	"    ( "
+	"        WITH per_column_stats AS "
+	"        ( "
+	"            SELECT "
+	"                s.stainherit, "
+	"                a.attname, "
+	"                jsonb_build_object( "
+	"                    'stanullfrac', s.stanullfrac::text, "
+	"                    'stawidth', s.stawidth::text, "
+	"                    'stadistinct', s.stadistinct::text, "
+	"                    'stakinds', "
+	"                    ( "
+	"                        SELECT "
+	"                            jsonb_agg( "
+	"                                CASE kind.kind "
+	"                                    WHEN 0 THEN 'TRIVIAL' "
+	"                                    WHEN 1 THEN 'MCV' "
+	"                                    WHEN 2 THEN 'HISTOGRAM' "
+	"                                    WHEN 3 THEN 'CORRELATION' "
+	"                                    WHEN 4 THEN 'MCELEM' "
+	"                                    WHEN 5 THEN 'DECHIST' "
+	"                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                END::text "
+	"                                ORDER BY kind.ord) "
+	"                        FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                    s.stakind3, stakind4, "
+	"                                    s.stakind5]) "
+	"                             WITH ORDINALITY AS kind(kind, ord) "
+	"                    ), "
+	"                    'stanumbers', "
+	"                    jsonb_build_array( "
+	"                        s.stanumbers1::text::text[], "
+	"                        s.stanumbers2::text::text[], "
+	"                        s.stanumbers3::text::text[], "
+	"                        s.stanumbers4::text::text[], "
+	"                        s.stanumbers5::text::text[]), "
+	"                    'stavalues', "
+	"                    jsonb_build_array( "
+	"                        s.stavalues1::text::text[], "
+	"                        s.stavalues2::text::text[], "
+	"                        s.stavalues3::text::text[], "
+	"                        s.stavalues4::text::text[], "
+	"                        s.stavalues5::text::text[]) "
+	"                ) AS stats "
+	"            FROM pg_attribute AS a "
+	"            JOIN pg_statistic AS s "
+	"                ON s.starelid = a.attrelid "
+	"                AND s.staattnum = a.attnum "
+	"            WHERE a.attrelid = r.oid "
+	"            AND NOT a.attisdropped "
+	"            AND a.attnum > 0 "
+	"            AND has_column_privilege(a.attrelid, a.attnum, 'SELECT') "
+	"        ), "
+	"        attagg AS "
+	"        ( "
+	"            SELECT "
+	"                pcs.stainherit, "
+	"                jsonb_build_object( "
+	"                    'columns', "
+	"                    jsonb_object_agg( "
+	"                        pcs.attname, "
+	"                        pcs.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM per_column_stats AS pcs "
+	"            GROUP BY pcs.stainherit "
+	"        ), "
+	"        extended_object_stats AS "
+	"        ( "
+	"            SELECT "
+	"                false AS stxdinherit, "
+	"                e.stxname, "
+	"                jsonb_build_object( "
+	"                    'stxkinds', "
+	"                    to_jsonb(e.stxkind), "
+	"                    'stxdndistinct', "
+	"                    ndist.stxdndistinct, "
+	"                    'stxdndependencies', "
+	"                    ndep.stxdndependencies, "
+	"                    'stxdmcv', "
+	"                    mcv.stxdmcv, "
+	"                ) AS stats "
+	"            FROM pg_statistic_ext AS e "
+	"            JOIN pg_statistic_ext_data AS sd "
+	"                ON sd.stxoid = e.oid "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', string_to_array(nd.attnums, ', '), "
+	"                                'ndistinct', nd.ndistinct "
+	"                                ) "
+	"                            ORDER BY nd.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                         WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                ) AS ndist(stxdndistinct) ON sd.stxdndistinct IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', "
+	"                                string_to_array( replace(dep.attrs, ' => ', ', '), ', '), "
+	"                                'degree', "
+	"                                dep.degree "
+	"                                ) "
+	"                            ORDER BY dep.ord "
+	"                        ) "
+	"                    FROM json_each_text(sd.stxddependencies::text::json) "
+	"                         WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                ) AS ndep(stxdndependencies) ON sd.stxddependencies IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT NULL AS stxdmcv "
+	"                ) AS mcv(stxdmcv) ON sd.stxdmcv IS NOT NULL "
+	"            WHERE e.stxrelid = r.oid "
+	"        ), "
+	"        extagg AS "
+	"        ( "
+	"            SELECT "
+	"                eos.stxdinherit, "
+	"                jsonb_build_object( "
+	"                    'extended', "
+	"                    jsonb_object_agg( "
+	"                        eos.stxname, "
+	"                        eos.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM extended_object_stats AS eos "
+	"            GROUP BY eos.stxdinherit "
+	"        ) "
+	"        SELECT "
+	"            jsonb_object_agg( "
+	"                CASE coalesce(a.stainherit, e.stxdinherit) "
+	"                    WHEN TRUE THEN 'inherited' "
+	"                    ELSE 'regular' "
+	"                END, "
+	"                coalesce(a.stats, '{}'::jsonb) || coalesce(e.stats, '{}'::jsonb)  "
+	"            ) "
+	"        FROM attagg AS a "
+	"        FULL OUTER JOIN extagg e ON a.stainherit = e.stxdinherit "
+	"    ) AS stats "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n "
+	"    ON n.oid = r.relnamespace "
+	"WHERE relkind IN ('r', 'm', 'f', 'p') "
+	"AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
+
+/* v10-v11 are like v12, but ext_data is gone and ndistinct and dependencies are on ext */
+const char *export_query_v10 = 
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    r.reltuples::float4 AS n_tuples, "
+	"    r.relpages::integer AS n_pages, "
+	"    ( "
+	"        WITH per_column_stats AS "
+	"        ( "
+	"            SELECT "
+	"                s.stainherit, "
+	"                a.attname, "
+	"                jsonb_build_object( "
+	"                    'stanullfrac', s.stanullfrac::text, "
+	"                    'stawidth', s.stawidth::text, "
+	"                    'stadistinct', s.stadistinct::text, "
+	"                    'stakinds', "
+	"                    ( "
+	"                        SELECT "
+	"                            jsonb_agg( "
+	"                                CASE kind.kind "
+	"                                    WHEN 0 THEN 'TRIVIAL' "
+	"                                    WHEN 1 THEN 'MCV' "
+	"                                    WHEN 2 THEN 'HISTOGRAM' "
+	"                                    WHEN 3 THEN 'CORRELATION' "
+	"                                    WHEN 4 THEN 'MCELEM' "
+	"                                    WHEN 5 THEN 'DECHIST' "
+	"                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                END::text "
+	"                                ORDER BY kind.ord) "
+	"                        FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                    s.stakind3, stakind4, "
+	"                                    s.stakind5]) "
+	"                             WITH ORDINALITY AS kind(kind, ord) "
+	"                    ), "
+	"                    'stanumbers', "
+	"                    jsonb_build_array( "
+	"                        s.stanumbers1::text::text[], "
+	"                        s.stanumbers2::text::text[], "
+	"                        s.stanumbers3::text::text[], "
+	"                        s.stanumbers4::text::text[], "
+	"                        s.stanumbers5::text::text[]), "
+	"                    'stavalues', "
+	"                    jsonb_build_array( "
+	"                        s.stavalues1::text::text[], "
+	"                        s.stavalues2::text::text[], "
+	"                        s.stavalues3::text::text[], "
+	"                        s.stavalues4::text::text[], "
+	"                        s.stavalues5::text::text[]) "
+	"                ) AS stats "
+	"            FROM pg_attribute AS a "
+	"            JOIN pg_statistic AS s "
+	"                ON s.starelid = a.attrelid "
+	"                AND s.staattnum = a.attnum "
+	"            WHERE a.attrelid = r.oid "
+	"            AND NOT a.attisdropped "
+	"            AND a.attnum > 0 "
+	"            AND has_column_privilege(a.attrelid, a.attnum, 'SELECT') "
+	"        ), "
+	"        attagg AS "
+	"        ( "
+	"            SELECT "
+	"                pcs.stainherit, "
+	"                jsonb_build_object( "
+	"                    'columns', "
+	"                    jsonb_object_agg( "
+	"                        pcs.attname, "
+	"                        pcs.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM per_column_stats AS pcs "
+	"            GROUP BY pcs.stainherit "
+	"        ), "
+	"        extended_object_stats AS "
+	"        ( "
+	"            SELECT "
+	"                false AS stxdinherit, "
+	"                e.stxname, "
+	"                jsonb_build_object( "
+	"                    'stxkinds', "
+	"                    to_jsonb(e.stxkind), "
+	"                    'stxdndistinct', "
+	"                    ndist.stxdndistinct, "
+	"                    'stxdndependencies', "
+	"                    ndep.stxdndependencies, "
+	"                ) AS stats "
+	"            FROM pg_statistic_ext AS e "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', string_to_array(nd.attnums, ', '), "
+	"                                'ndistinct', nd.ndistinct "
+	"                                ) "
+	"                            ORDER BY nd.ord "
+	"                        ) "
+	"                    FROM json_each_text(e.stxndistinct::text::json) "
+	"                         WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                ) AS ndist(stxdndistinct) ON e.stxndistinct IS NOT NULL "
+	"            LEFT JOIN LATERAL "
+	"                ( "
+	"                    SELECT "
+	"                        jsonb_agg( "
+	"                            jsonb_build_object( "
+	"                                'attnums', "
+	"                                string_to_array( replace(dep.attrs, ' => ', ', '), ', '), "
+	"                                'degree', "
+	"                                dep.degree "
+	"                                ) "
+	"                            ORDER BY dep.ord "
+	"                        ) "
+	"                    FROM json_each_text(.stxdependencies::text::json) "
+	"                         WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                ) AS ndep(stxdndependencies) ON e.stxdependencies IS NOT NULL "
+	"            WHERE e.stxrelid = r.oid "
+	"        ), "
+	"        extagg AS "
+	"        ( "
+	"            SELECT "
+	"                eos.stxdinherit, "
+	"                jsonb_build_object( "
+	"                    'extended', "
+	"                    jsonb_object_agg( "
+	"                        eos.stxname, "
+	"                        eos.stats "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM extended_object_stats AS eos "
+	"            GROUP BY eos.stxdinherit "
+	"        ) "
+	"        SELECT "
+	"            jsonb_object_agg( "
+	"                CASE coalesce(a.stainherit, e.stxdinherit) "
+	"                    WHEN TRUE THEN 'inherited' "
+	"                    ELSE 'regular' "
+	"                END, "
+	"                coalesce(a.stats, '{}'::jsonb) || coalesce(e.stats, '{}'::jsonb)  "
+	"            ) "
+	"        FROM attagg AS a "
+	"        FULL OUTER JOIN extagg e ON a.stainherit = e.stxdinherit "
+	"    ) AS stats "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n "
+	"    ON n.oid = r.relnamespace "
+	"WHERE relkind IN ('r', 'm', 'f', 'p') "
+	"AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
+
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"echo", no_argument, NULL, 'e'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		echo = false;
+
+	PQExpBufferData sql;
+	
+	PGconn	   *conn;
+
+	FILE	   *copystream = stdout;
+
+	PGresult   *result;
+
+	ExecStatusType result_status;
+
+	char	   *buf;
+	int			ret;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:eh:p:U:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'e':
+				echo = true;
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, echo, false, true);
+
+	initPQExpBuffer(&sql);
+
+	appendPQExpBufferStr(&sql, "COPY (");
+
+	if (PQserverVersion(conn) >= 170000)
+		appendPQExpBufferStr(&sql, export_query_v17);
+	else if (PQserverVersion(conn) >= 150000)
+		appendPQExpBufferStr(&sql, export_query_v15);
+	else if (PQserverVersion(conn) >= 140000)
+		appendPQExpBufferStr(&sql, export_query_v14);
+	else if (PQserverVersion(conn) >= 120000)
+		appendPQExpBufferStr(&sql, export_query_v12);
+	else if (PQserverVersion(conn) >= 100000)
+		appendPQExpBufferStr(&sql, export_query_v10);
+	else
+		pg_fatal("exporting statistics from databases prior to version 10 not supported");
+
+	appendPQExpBufferStr(&sql, ") TO STDOUT");
+
+	result = PQexec(conn, sql.data);
+	result_status = PQresultStatus(result);
+
+	if (result_status != PGRES_COPY_OUT)
+		pg_fatal("malformed copy command");
+
+	for (;;)
+	{
+		ret = PQgetCopyData(conn, &buf, 0);
+
+		if (ret < 0)
+			break;				/* done or server/connection error */
+
+		if (buf)
+		{
+			if (copystream && fwrite(buf, 1, ret, copystream) != ret)
+				pg_fatal("could not write COPY data: %m");
+			PQfreemem(buf);
+		}
+	}
+
+	if (copystream && fflush(copystream))
+		pg_fatal("could not write COPY data: %m");
+
+	if (ret == -2)
+		pg_fatal("COPY data transfer failed: %s", PQerrorMessage(conn));
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -e, --echo                show the commands being sent to the server\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
diff --git a/src/bin/scripts/pg_import_stats.c b/src/bin/scripts/pg_import_stats.c
new file mode 100644
index 0000000000..cfcadff769
--- /dev/null
+++ b/src/bin/scripts/pg_import_stats.c
@@ -0,0 +1,303 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_import_stats
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_import_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+#define COPY_BUF_LEN 8192
+
+static void help(const char *progname);
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"quiet", no_argument, NULL, 'q'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		quiet = false;
+
+	PGconn	   *conn;
+
+	FILE	   *copysrc= stdin;
+
+	PGresult   *result;
+
+	int		i;
+	int		numtables;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:h:p:qU:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'q':
+				quiet = true;
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, false, false, true);
+
+	/* open file */
+
+	/* iterate over records */
+
+
+	result = PQexec(conn, 
+		"CREATE TEMPORARY TABLE import_stats ( "
+		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
+		"schemaname text, relname text, server_version_num integer, "
+		"n_tuples float4, n_pages integer, stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary file: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	result = PQexec(conn, 
+		"COPY import_stats(schemaname, relname, server_version_num, n_tuples, "
+		"n_pages, stats) FROM STDIN");
+
+	if (PQresultStatus(result) != PGRES_COPY_IN)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	for (;;)
+	{
+		char copybuf[COPY_BUF_LEN];
+
+		int numread = fread(copybuf, 1, COPY_BUF_LEN, copysrc);
+
+		if (ferror(copysrc))
+			pg_fatal("error reading from source");
+
+		if (numread == 0)
+			break;
+
+		if (PQputCopyData(conn, copybuf, numread) == -1)
+			pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	}
+
+	if (PQputCopyEnd(conn, NULL) == -1)
+		pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	fclose(copysrc);
+
+	result = PQgetResult(conn);
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	numtables = atol(PQcmdTuples(result));
+
+	PQclear(result);
+
+	result = PQprepare(conn, "import", 
+		"SELECT pg_import_rel_stats(c.oid, s.server_version_num, "
+		"             s.n_tuples, s.n_pages, s.stats) as import_result "
+		"FROM import_stats AS s "
+		"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+		"JOIN pg_class AS c ON c.relnamespace = n.oid " 
+		"                   AND c.relname = s.relname "
+		"WHERE s.id = $1::bigint ",
+		1, NULL);
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	if (!quiet)
+	{
+		result = PQprepare(conn, "echo", 
+			"SELECT s.schemaname, s.relname "
+			"FROM import_stats AS s "
+			"WHERE s.id = $1::bigint ",
+			1, NULL);
+
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+		PQclear(result);
+	}
+
+	for (i = 1; i <= numtables; i++)
+	{
+		char	istr[32];
+		char   *schema = NULL;
+		char   *table = NULL;
+
+		const char *const values[] = {istr};
+
+		snprintf(istr, 32, "%d", i);
+
+		if (!quiet)
+		{
+			result = PQexecPrepared(conn, "echo", 1, values, NULL, NULL, 0);
+			schema = pg_strdup(PQgetvalue(result, 0, 0));
+			table = pg_strdup(PQgetvalue(result, 0, 1));
+		}
+
+		PQclear(result);
+
+		result = PQexecPrepared(conn, "import", 1, values, NULL, NULL, 0);
+
+		if (quiet)
+		{
+			PQclear(result);
+			continue;
+		}
+
+		if (PQresultStatus(result) == PGRES_TUPLES_OK)
+		{
+			int 	rows = PQntuples(result);
+
+			if (rows == 1)
+			{
+				char   *retval = PQgetvalue(result, 0, 0);
+				if (*retval == 't')
+					printf("%s.%s: imported\n", schema, table);
+				else
+					printf("%s.%s: failed\n", schema, table);
+			}
+			else if (rows == 0)
+				printf("%s.%s: not found\n", schema, table);
+			else
+				pg_fatal("import function must return 0 or 1 rows");
+		}
+		else
+			printf("%s.%s: error: %s\n", schema, table, PQerrorMessage(conn));
+
+		if (schema != NULL)
+			pfree(schema);
+
+		if (table != NULL)
+			pfree(table);
+
+		PQclear(result);
+	}
+
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -q, --quiet               don't write any messages\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
-- 
2.41.0

From 4ae4ac484bcaf4b74fef1284d63e6e6d4d6a236f Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 12 Dec 2023 20:48:42 -0500
Subject: [PATCH v3 2/9] Add system view pg_statistic_export.

This view is designed to aid in the export (and re-import) of table
statistics, mostly for upgrade/restore situations.
---
 src/backend/catalog/system_views.sql | 84 ++++++++++++++++++++++++++++
 src/test/regress/expected/rules.out  | 31 ++++++++++
 doc/src/sgml/system-views.sgml       |  5 ++
 3 files changed, 120 insertions(+)

diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 11d18ed9dd..7655bf7458 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -274,6 +274,90 @@ CREATE VIEW pg_stats WITH (security_barrier) AS
 
 REVOKE ALL ON pg_statistic FROM public;
 
+
+
+CREATE VIEW pg_statistic_export WITH (security_barrier) AS
+    SELECT
+        n.nspname AS schemaname,
+        r.relname AS relname,
+        current_setting('server_version_num')::integer AS server_version_num,
+        r.reltuples::float4 AS n_tuples,
+        r.relpages::integer AS n_pages,
+        (
+            SELECT
+                jsonb_object_agg(
+                    CASE
+                        WHEN a.stainherit THEN 'inherited'
+                        ELSE 'regular'
+                    END,
+                    a.stats
+                )
+            FROM
+            (
+                SELECT
+                    s.stainherit,
+                    jsonb_object_agg(
+                        a.attname,
+                        jsonb_build_object(
+                            'stanullfrac', s.stanullfrac::text,
+                            'stawidth', s.stawidth::text,
+                            'stadistinct', s.stadistinct::text,
+                            'stakinds',
+                            (
+                                SELECT
+                                    jsonb_agg(
+                                        CASE kind.kind
+                                            WHEN 0 THEN 'TRIVIAL'
+                                            WHEN 1 THEN 'MCV'
+                                            WHEN 2 THEN 'HISTOGRAM'
+                                            WHEN 3 THEN 'CORRELATION'
+                                            WHEN 4 THEN 'MCELEM'
+                                            WHEN 5 THEN 'DECHIST'
+                                            WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'
+                                            WHEN 7 THEN 'BOUNDS_HISTOGRAM'
+                                        END::text
+                                        ORDER BY kind.ord)
+                                FROM unnest(ARRAY[s.stakind1, s.stakind2,
+                                            s.stakind3, stakind4,
+                                            s.stakind5])
+                                     WITH ORDINALITY AS kind(kind, ord)
+                            ),
+                            'stanumbers',
+                            jsonb_build_array(
+                                s.stanumbers1::text,
+                                s.stanumbers2::text,
+                                s.stanumbers3::text,
+                                s.stanumbers4::text,
+                                s.stanumbers5::text),
+                            'stavalues',
+                            jsonb_build_array(
+                                -- casting to text makes it easier to import using array_in()
+                                s.stavalues1::text,
+                                s.stavalues2::text,
+                                s.stavalues3::text,
+                                s.stavalues4::text,
+                                s.stavalues5::text)
+                        )
+                    ) AS stats
+                FROM pg_attribute AS a
+                JOIN pg_statistic AS s
+                    ON s.starelid = a.attrelid
+                    AND s.staattnum = a.attnum
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+                AND has_column_privilege(a.attrelid, a.attnum, 'SELECT')
+                GROUP BY s.stainherit
+            ) AS a
+        ) AS stats
+    FROM pg_class AS r
+    JOIN pg_namespace AS n
+        ON n.oid = r.relnamespace
+    WHERE relkind IN ('r', 'm', 'f', 'p', 'i')
+    AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema');
+
+
+
 CREATE VIEW pg_stats_ext WITH (security_barrier) AS
     SELECT cn.nspname AS schemaname,
            c.relname AS tablename,
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 05070393b9..f2b059af5e 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -2404,6 +2404,37 @@ pg_statio_user_tables| SELECT relid,
     tidx_blks_hit
    FROM pg_statio_all_tables
   WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text));
+pg_statistic_export| SELECT n.nspname AS schemaname,
+    r.relname,
+    (current_setting('server_version_num'::text))::integer AS server_version_num,
+    r.reltuples AS n_tuples,
+    r.relpages AS n_pages,
+    ( SELECT jsonb_object_agg(
+                CASE
+                    WHEN a.stainherit THEN 'inherited'::text
+                    ELSE 'regular'::text
+                END, a.stats) AS jsonb_object_agg
+           FROM ( SELECT s.stainherit,
+                    jsonb_object_agg(a_1.attname, jsonb_build_object('stanullfrac', (s.stanullfrac)::text, 'stawidth', (s.stawidth)::text, 'stadistinct', (s.stadistinct)::text, 'stakinds', ( SELECT jsonb_agg(
+                                CASE kind.kind
+                                    WHEN 0 THEN 'TRIVIAL'::text
+                                    WHEN 1 THEN 'MCV'::text
+                                    WHEN 2 THEN 'HISTOGRAM'::text
+                                    WHEN 3 THEN 'CORRELATION'::text
+                                    WHEN 4 THEN 'MCELEM'::text
+                                    WHEN 5 THEN 'DECHIST'::text
+                                    WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'::text
+                                    WHEN 7 THEN 'BOUNDS_HISTOGRAM'::text
+                                    ELSE NULL::text
+                                END ORDER BY kind.ord) AS jsonb_agg
+                           FROM unnest(ARRAY[s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5]) WITH ORDINALITY kind(kind, ord)), 'stanumbers', jsonb_build_array((s.stanumbers1)::text, (s.stanumbers2)::text, (s.stanumbers3)::text, (s.stanumbers4)::text, (s.stanumbers5)::text), 'stavalues', jsonb_build_array((s.stavalues1)::text, (s.stavalues2)::text, (s.stavalues3)::text, (s.stavalues4)::text, (s.stavalues5)::text))) AS stats
+                   FROM (pg_attribute a_1
+                     JOIN pg_statistic s ON (((s.starelid = a_1.attrelid) AND (s.staattnum = a_1.attnum))))
+                  WHERE ((a_1.attrelid = r.oid) AND (NOT a_1.attisdropped) AND (a_1.attnum > 0) AND has_column_privilege(a_1.attrelid, a_1.attnum, 'SELECT'::text))
+                  GROUP BY s.stainherit) a) AS stats
+   FROM (pg_class r
+     JOIN pg_namespace n ON ((n.oid = r.relnamespace)))
+  WHERE ((r.relkind = ANY (ARRAY['r'::"char", 'm'::"char", 'f'::"char", 'p'::"char", 'i'::"char"])) AND (n.nspname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name])));
 pg_stats| SELECT n.nspname AS schemaname,
     c.relname AS tablename,
     a.attname,
diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 0ef1745631..91b3ab22fb 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -191,6 +191,11 @@
       <entry>extended planner statistics for expressions</entry>
      </row>
 
+     <row>
+      <entry><link linkend="view-pg-stats"><structname>pg_stats_export</structname></link></entry>
+      <entry>planner statistics for export/upgrade purposes</entry>
+     </row>
+
      <row>
       <entry><link linkend="view-pg-tables"><structname>pg_tables</structname></link></entry>
       <entry>tables</entry>
-- 
2.43.0

From 7cc09a452ce4407fad83e0fcc9723d43121d4db1 Mon Sep 17 00:00:00 2001
From: coreyhuinker <corey.huinker@gmail.com>
Date: Mon, 30 Oct 2023 16:21:30 -0400
Subject: [PATCH v3 1/9] Additional internal jsonb access functions.

Make JsonbContainerTypeName externally visible.

Add JsonbStringValueToCString.
---
 src/include/utils/jsonb.h          |  4 ++++
 src/backend/utils/adt/jsonb.c      |  2 +-
 src/backend/utils/adt/jsonb_util.c | 15 +++++++++++++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/jsonb.h b/src/include/utils/jsonb.h
index addc9b608e..b3c1e104f2 100644
--- a/src/include/utils/jsonb.h
+++ b/src/include/utils/jsonb.h
@@ -424,6 +424,8 @@ extern char *JsonbToCStringIndent(StringInfo out, JsonbContainer *in,
 								  int estimated_len);
 extern bool JsonbExtractScalar(JsonbContainer *jbc, JsonbValue *res);
 extern const char *JsonbTypeName(JsonbValue *val);
+extern const char *JsonbContainerTypeName(JsonbContainer *jbc);
+
 
 extern Datum jsonb_set_element(Jsonb *jb, Datum *path, int path_len,
 							   JsonbValue *newval);
@@ -436,4 +438,6 @@ extern Datum jsonb_build_object_worker(int nargs, const Datum *args, const bool
 extern Datum jsonb_build_array_worker(int nargs, const Datum *args, const bool *nulls,
 									  const Oid *types, bool absent_on_null);
 
+extern char *JsonbStringValueToCString(JsonbValue *j);
+
 #endif							/* __JSONB_H__ */
diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c
index 6f445f5c2b..0ad4e81d89 100644
--- a/src/backend/utils/adt/jsonb.c
+++ b/src/backend/utils/adt/jsonb.c
@@ -160,7 +160,7 @@ jsonb_from_text(text *js, bool unique_keys)
 /*
  * Get the type name of a jsonb container.
  */
-static const char *
+const char *
 JsonbContainerTypeName(JsonbContainer *jbc)
 {
 	JsonbValue	scalar;
diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 9cc95b773d..ae311b38ba 100644
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -1992,3 +1992,18 @@ uniqueifyJsonbObject(JsonbValue *object, bool unique_keys, bool skip_nulls)
 		}
 	}
 }
+
+/*
+ * Extract a JsonbValue as a cstring.
+ */
+char *JsonbStringValueToCString(JsonbValue *j)
+{
+	char *s;
+
+	Assert(j->type == jbvString);
+	/* make a string that we are sure is null-terminated */
+	s = palloc(j->val.string.len + 1);
+	memcpy(s, j->val.string.val, j->val.string.len);
+	s[j->val.string.len] = '\0';
+	return s;
+}
-- 
2.43.0

From 2260a0f53572d8422857237e4065da619401a0f1 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 12 Dec 2023 22:21:42 -0500
Subject: [PATCH v3 3/9] Add pg_import_rel_stats()

The function pg_import_rel_stats imports rowcount, pagecount, and column
statistics for a given table or index.

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a best-effort approach, skipping statistics that are
expected but omitted, skipping object that are specified but do not
exist on the target system. The goal is to get better-than-empty
statistics into the table quickly, so that business operations can
resume sooner.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

While the statistics are applied transactionally, the changes to
pg_class (reltuples and relpages) are not. This decision was made
to avoid bloat of pg_class and is in line with the behavior of VACUUM.

The medium of exchange is jsonb, the format of which is specified in the
view pg_statistic_export. Obviously this view does not exist in older
versions of the database, but the view definition can be extracted and
adapted to older versions.

This function also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   5 +
 src/include/statistics/statistics.h           |  16 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 806 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 137 +++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 119 +++
 doc/src/sgml/func.sgml                        |  43 +
 9 files changed, 1130 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 77e8b13764..4d1e9bde1f 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5655,6 +5655,11 @@
   proname => 'pg_stat_get_db_stat_reset_time', provolatile => 's',
   proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
   prosrc => 'pg_stat_get_db_stat_reset_time' },
+{ oid => '3814',
+  descr => 'statistics: import to relation',
+  proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid int4 float4 int4 jsonb',
+  prosrc => 'pg_import_rel_stats' },
 { oid => '3150', descr => 'statistics: number of temporary files written',
   proname => 'pg_stat_get_db_temp_files', provolatile => 's',
   proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 5e538fec32..4251558593 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -15,6 +15,7 @@
 
 #include "commands/vacuum.h"
 #include "nodes/pathnodes.h"
+#include "utils/jsonb.h"
 
 #define STATS_MAX_DIMENSIONS	8	/* max number of attributes */
 
@@ -101,6 +102,7 @@ extern MCVList *statext_mcv_load(Oid mvoid, bool inh);
 extern void BuildRelationExtStatistics(Relation onerel, bool inh, double totalrows,
 									   int numrows, HeapTuple *rows,
 									   int natts, VacAttrStats **vacattrstats);
+
 extern int	ComputeExtStatisticsRows(Relation onerel,
 									 int natts, VacAttrStats **vacattrstats);
 extern bool statext_is_kind_built(HeapTuple htup, char type);
@@ -127,4 +129,18 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern char *key_lookup_cstring(JsonbContainer *cont, const char *key);
+extern JsonbContainer *key_lookup_object(JsonbContainer *cont, const char *key);
+extern JsonbContainer *key_lookup_array(JsonbContainer *cont, const char *key);
+
+extern Datum pg_import_rel_stats(PG_FUNCTION_ARGS);
+
+extern VacAttrStats *examine_rel_attribute(Form_pg_attribute attr,
+										   Relation onerel, Node *index_expr);
+
+extern
+void import_attribute(Oid relid, const VacAttrStats *stat,
+					  JsonbContainer *cont, bool inh, Datum values[],
+					  bool nulls[], bool replaces[]);
+
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index e12737b011..1e6e100d3c 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c'
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..968ccfaaf2
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,806 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics.c
+ *
+ * IDENTIFICATION
+ *	  src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_collation.h"
+#include "catalog/pg_type.h"
+#include "catalog/pg_operator.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "utils/builtins.h"
+#include "utils/datum.h" /* REMOVE */
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/jsonb.h"
+#include "utils/numeric.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+#include "statistics/statistics.h"
+
+
+static int16
+decode_stakind_string(char *s);
+
+static
+void import_pg_statistic(Relation rel, bool inh, JsonbContainer *cont);
+
+static
+void import_stakinds(const VacAttrStats *stat, JsonbContainer *cont,
+					 bool inh, int16 kindenums[], Datum kindvalues[],
+					 bool kindnulls[], bool kindreplaces[], Datum opvalues[],
+					 bool opnulls[], bool opreplaces[], Datum collvalues[],
+					 bool collnulls[], bool collreplaces[]);
+
+static
+void import_stanumbers(const VacAttrStats *stat, JsonbContainer *cont,
+					   Datum kindvalues[], bool kindnulls[],
+					   bool kindreplaces[]);
+
+static
+void import_stavalues(const VacAttrStats *stat, JsonbContainer *cont,
+					  int16 kindenums[], Datum valvalues[],
+					  bool valnulls[], bool valreplaces[]);
+
+
+/*
+ * Import staistic from:
+ *   root->"regular"
+ *   and
+ *   root->"inherited"
+ *
+ * Container format is:
+ *
+ * {
+ * 	 "colname1": { ...per column stats... },
+ * 	 "colname2": { ...per column stats... },
+ *   ...
+ * }
+ *
+ */
+static
+void import_pg_statistic(Relation rel, bool inh, JsonbContainer *cont)
+{
+	TupleDesc   		tupdesc = RelationGetDescr(rel);
+	Oid					relid = RelationGetRelid(rel);
+	int					natts = tupdesc->natts;
+	CatalogIndexState	indstate = NULL;
+	Relation			sd;
+	int					i;
+	bool				has_index_exprs = false;
+	ListCell		   *indexpr_item = NULL;
+
+	if (cont == NULL)
+		return;
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/*
+	 * If this relation is an index and that index has expressions in
+	 * it, then we will need to keep the list of remaining expressions
+	 * aligned with the attributes as we iterate over them, whether or
+	 * not those attributes have statistics to import.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+			|| (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		 && (rel->rd_indexprs != NIL))
+	{
+		has_index_exprs = true;
+		indexpr_item = list_head(rel->rd_indexprs);
+	}
+
+	for (i = 0; i < natts; i++)
+	{
+
+		Form_pg_attribute	att;
+		char			   *name;
+		JsonbContainer	   *attrcont;
+		VacAttrStats	   *stat;
+		Node			   *index_expr = NULL;
+
+		att = TupleDescAttr(tupdesc, i);
+
+		if (att->attisdropped)
+			continue;
+
+		if (has_index_exprs && (rel->rd_index->indkey.values[i] == 0))
+		{
+			if (indexpr_item == NULL)   /* shouldn't happen */
+				elog(ERROR, "too few entries in indexprs list");
+
+			index_expr = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+		}
+
+		stat = examine_rel_attribute(att, rel, index_expr);
+
+		name = NameStr(att->attname);
+
+		attrcont = key_lookup_object(cont, name);
+
+		if (attrcont != NULL)
+		{
+			Datum		values[Natts_pg_statistic] = { 0 };
+			bool		nulls[Natts_pg_statistic] = { false };
+			bool		replaces[Natts_pg_statistic] = { false };
+			HeapTuple	stup,
+						oldtup;
+
+			import_attribute(relid, stat, attrcont, inh, values, nulls, replaces);
+
+			/* Is there already a pg_statistic tuple for this attribute? */
+			oldtup = SearchSysCache3(STATRELATTINH,
+									 ObjectIdGetDatum(RelationGetRelid(rel)),
+									 Int16GetDatum(att->attnum),
+									 BoolGetDatum(inh));
+
+			/* Open index information when we know we need it */
+			if (indstate == NULL)
+				indstate = CatalogOpenIndexes(sd);
+
+			if (HeapTupleIsValid(oldtup))
+			{
+				/* Yes, replace it */
+				stup = heap_modify_tuple(oldtup,
+										 RelationGetDescr(sd),
+										 values,
+										 nulls,
+										 replaces);
+				ReleaseSysCache(oldtup);
+				CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+			}
+			else
+			{
+				/* No, insert new tuple */
+				stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+				CatalogTupleInsertWithInfo(sd, stup, indstate);
+			}
+			heap_freetuple(stup);
+		}
+		/* DEBUG pfree(stat); */
+	}
+
+	if (indstate != NULL)
+		CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+}
+
+/*
+ * Import statitics for one attribute
+ *
+ */
+void
+import_attribute(Oid relid, const VacAttrStats *stat,
+				 JsonbContainer *cont, bool inh,
+				 Datum values[], bool nulls[], bool replaces[])
+{
+	JsonbContainer *arraycont;
+	char		   *s;
+	int16			kindenums[STATISTIC_NUM_SLOTS] = {0};
+
+	Assert(cont != NULL);
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(stat->tupattnum);
+	values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(inh);
+
+	s = key_lookup_cstring(cont, "stanullfrac");
+	if (s != NULL)
+	{
+		float4 f = float4in_internal(s, NULL, "real", s, NULL);
+		pfree(s);
+		values[Anum_pg_statistic_stanullfrac - 1] = Float4GetDatum(f);
+		replaces[Anum_pg_statistic_stanullfrac - 1] = true;
+	}
+
+	s = key_lookup_cstring(cont, "stawidth");
+	if (s != NULL)
+	{
+		int32 d = pg_strtoint32(s);
+		pfree(s);
+		values[Anum_pg_statistic_stawidth - 1] = Int32GetDatum(d);
+		replaces[Anum_pg_statistic_stawidth - 1] = true;
+	}
+
+	s = key_lookup_cstring(cont, "stadistinct");
+	if (s != NULL)
+	{
+		float4 f = float4in_internal(s, NULL, "real", s, NULL);
+		pfree(s);
+		values[Anum_pg_statistic_stadistinct - 1] = Float4GetDatum(f);
+		replaces[Anum_pg_statistic_stadistinct - 1] = true;
+	}
+
+	arraycont = key_lookup_array(cont, "stakinds");
+	import_stakinds(stat, arraycont, inh, kindenums,
+					&values[Anum_pg_statistic_stakind1 - 1],
+					&nulls[Anum_pg_statistic_stakind1 - 1],
+					&replaces[Anum_pg_statistic_stakind1 - 1],
+					&values[Anum_pg_statistic_staop1 - 1],
+					&nulls[Anum_pg_statistic_staop1 - 1],
+					&replaces[Anum_pg_statistic_staop1 - 1],
+					&values[Anum_pg_statistic_stacoll1 - 1],
+					&nulls[Anum_pg_statistic_stacoll1 - 1],
+					&replaces[Anum_pg_statistic_stacoll1 - 1]);
+
+	arraycont = key_lookup_array(cont, "stanumbers");
+	import_stanumbers(stat, arraycont,
+					  &values[Anum_pg_statistic_stanumbers1 - 1],
+					  &nulls[Anum_pg_statistic_stanumbers1 - 1],
+					  &replaces[Anum_pg_statistic_stanumbers1 - 1]);
+
+	arraycont = key_lookup_array(cont, "stavalues");
+	import_stavalues(stat, arraycont, kindenums,
+					 &values[Anum_pg_statistic_stavalues1 - 1],
+					 &nulls[Anum_pg_statistic_stavalues1 - 1],
+					 &replaces[Anum_pg_statistic_stavalues1 - 1]);
+}
+
+/*
+ * import stakinds values from json, the values of which determine
+ * the staop and stacoll values to use as well.
+ */
+static
+void import_stakinds(const VacAttrStats *stat, JsonbContainer *cont,
+					 bool inh, int16 kindenums[], Datum kindvalues[],
+					 bool kindnulls[], bool kindreplaces[], Datum opvalues[],
+					 bool opnulls[], bool opreplaces[], Datum collvalues[],
+					 bool collnulls[], bool collreplaces[])
+{
+	int k;
+	int numkinds = 0;
+
+	if (cont != NULL)
+	{
+		TypeCacheEntry *typentry = lookup_type_cache(stat->attrtypid,
+													TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR);
+		Datum	lt_opr = ObjectIdGetDatum(typentry->lt_opr);
+		Datum	eq_opr = ObjectIdGetDatum(typentry->eq_opr);
+
+		numkinds = JsonContainerSize(cont);
+
+		if (numkinds > STATISTIC_NUM_SLOTS)
+			ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				errmsg("invalid format: number of stakinds %d is greater than available slots %d",
+						numkinds, STATISTIC_NUM_SLOTS)));
+
+		for (k = 0; k < numkinds; k++)
+		{
+			JsonbValue *j = getIthJsonbValueFromContainer(cont, k);
+			int16		kind;
+			char	   *s;
+
+			if (j == NULL || (j->type != jbvString))
+				ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					errmsg("invalid format: stakind elements must be strings")));
+
+			s = JsonbStringValueToCString(j);
+			kind = decode_stakind_string(s);
+			pfree(s);
+			pfree(j);
+
+			kindenums[k] = kind;
+			kindvalues[k] = Int16GetDatum(kind);
+			kindreplaces[k] = true;
+
+			switch(kind)
+			{
+				case STATISTIC_KIND_MCV:
+					opvalues[k] = eq_opr;
+					opreplaces[k] = true;
+					collvalues[k] = ObjectIdGetDatum(stat->attrcollid);
+					collreplaces[k] = true;
+					break;
+
+				case STATISTIC_KIND_HISTOGRAM:
+				case STATISTIC_KIND_CORRELATION:
+					opvalues[k] = lt_opr;
+					opreplaces[k] = true;
+					collvalues[k] = ObjectIdGetDatum(stat->attrcollid);
+					collreplaces[k] = true;
+					break;
+
+				case STATISTIC_KIND_MCELEM:
+				case STATISTIC_KIND_DECHIST:
+					opvalues[k] = ObjectIdGetDatum(TextEqualOperator);
+					opreplaces[k] = true;
+					collvalues[k] = ObjectIdGetDatum(DEFAULT_COLLATION_OID);
+					collreplaces[k] = true;
+					break;
+
+				case STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM:
+					opvalues[k] = ObjectIdGetDatum(Float8LessOperator);
+					opreplaces[k] = true;
+					collvalues[k] = ObjectIdGetDatum(InvalidOid);
+					collreplaces[k] = true;
+					break;
+
+				case STATISTIC_KIND_BOUNDS_HISTOGRAM:
+				default:
+					opvalues[k] = ObjectIdGetDatum(InvalidOid);
+					opreplaces[k] = true;
+					collvalues[k] = ObjectIdGetDatum(InvalidOid);
+					collreplaces[k] = true;
+					break;
+			}
+		}
+	}
+
+	/* fill out empty slots, but do not replace */
+	for (k = numkinds; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		kindvalues[k] = Int16GetDatum(0);
+		opvalues[k] = ObjectIdGetDatum(InvalidOid);
+		collvalues[k] = ObjectIdGetDatum(InvalidOid);
+	}
+}
+
+static
+void import_stanumbers(const VacAttrStats *stat, JsonbContainer *cont,
+					   Datum numvalues[], bool numnulls[],
+					   bool numreplaces[])
+{
+	int numnumbers = 0;
+	int k;
+
+	if (cont != NULL)
+	{
+		FmgrInfo	finfo;
+
+		numnumbers = JsonContainerSize(cont);
+
+		if (numnumbers > STATISTIC_NUM_SLOTS)
+			ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				errmsg("invalid format: number of stanumbers %d is greater than available slots %d",
+						numnumbers, STATISTIC_NUM_SLOTS)));
+
+		fmgr_info(F_ARRAY_IN, &finfo);
+
+		for (k = 0; k < numnumbers; k++)
+		{
+			JsonbValue *j = getIthJsonbValueFromContainer(cont, k);
+
+			if (j == NULL)
+			{
+				numvalues[k] = (Datum) 0;
+				numnulls[k] = true;
+				continue;
+			}
+
+			if (j->type == jbvNull)
+			{
+				numvalues[k] = (Datum) 0;
+				numnulls[k] = true;
+				pfree(j);
+				continue;
+			}
+
+			if (j->type == jbvString)
+			{
+				char *s = JsonbStringValueToCString(j);
+
+				numvalues[k] = FunctionCall3(&finfo, CStringGetDatum(s),
+											 ObjectIdGetDatum(FLOAT4OID),
+											 Int32GetDatum(0));
+				numreplaces[k] = true;
+				pfree(s);
+				pfree(j);
+				continue;
+			}
+			else
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stanumbers elements "
+						  "must be a string that is castable to an array of floats")));
+
+		}
+	}
+
+	/* fill out empty slots, but do not replace */
+	for (k = numnumbers; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		numvalues[k] = (Datum) 0;
+		numnulls[k] = true;
+	}
+}
+
+static
+void import_stavalues(const VacAttrStats *stat, JsonbContainer *cont,
+					  int16 kindenums[], Datum valvalues[],
+					  bool valnulls[], bool valreplaces[])
+{
+	int numvals = 0;
+	int k;
+
+	if (cont != NULL)
+	{
+		FmgrInfo	finfo;
+
+		fmgr_info(F_ARRAY_IN, &finfo);
+		numvals = JsonContainerSize(cont);
+
+		if (numvals > STATISTIC_NUM_SLOTS)
+			ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				errmsg("invalid format: number of stavalues %d is greater than available slots %d",
+						numvals, STATISTIC_NUM_SLOTS)));
+
+		for (k = 0; k < numvals; k++)
+		{
+			JsonbValue *j = getIthJsonbValueFromContainer(cont, k);
+
+			if (j == NULL)
+			{
+				valvalues[k] = (Datum) 0;
+				valnulls[k] = true;
+				continue;
+			}
+
+			if (j->type == jbvNull)
+			{
+				valvalues[k] = (Datum) 0;
+				valnulls[k] = true;
+				pfree(j);
+				continue;
+			}
+
+			if (j->type == jbvString)
+			{
+				char   *s = JsonbStringValueToCString(j);
+				Oid		typoid = stat->statypid[k];
+				int32	typmod = 0;
+
+				/*
+				 * MCELEM stat arrays are of the same type as the
+				 * array base element type.
+				 */
+				if (kindenums[k] == STATISTIC_KIND_MCELEM)
+				{
+					TypeCacheEntry *typentry = lookup_type_cache(typoid, 0);
+					if (IsTrueArrayType(typentry))
+						typoid = typentry->typelem;
+				}
+				valvalues[k] = FunctionCall3(&finfo, CStringGetDatum(s),
+								 ObjectIdGetDatum(typoid),
+								 Int32GetDatum(typmod));
+				valreplaces[k] = true;
+				pfree(s);
+				pfree(j);
+			}
+			else
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, stavalues elements must "
+						  "be a string that is castable to an array of the "
+						  "column type")));
+
+		}
+	}
+
+	/* fill out empty slots, but do not replace */
+	for (k = numvals; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		valvalues[k] = (Datum) 0;
+		valnulls[k] = true;
+	}
+}
+
+/*
+ * Get a JsonbValue from a JsonbContainer and ensure that it is a string,
+ * and return the cstring.
+ */
+char *key_lookup_cstring(JsonbContainer *cont, const char *key)
+{
+	JsonbValue	j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvString)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be a string but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	return JsonbStringValueToCString(&j);
+}
+
+/*
+ * Get a JsonbContainer from a JsonbContainer and ensure that it is a object
+ */
+JsonbContainer *key_lookup_object(JsonbContainer *cont, const char *key)
+{
+	JsonbValue		j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvBinary)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an object but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	if (!JsonContainerIsObject(j.val.binary.data))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an object but is type %s",
+				  key, JsonbContainerTypeName(j.val.binary.data))));
+
+	return j.val.binary.data;
+}
+
+/*
+ * Get a JsonbContainer from a JsonbContainer and ensure that it is an array
+ */
+JsonbContainer *key_lookup_array(JsonbContainer *cont, const char *key)
+{
+	JsonbValue	j;
+
+	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
+		return NULL;
+
+	if (j.type != jbvBinary)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an array but is type %s",
+				  key, JsonbTypeName(&j))));
+
+	if (!JsonContainerIsArray(j.val.binary.data))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics format, %s must be an array but is type %s",
+				  key, JsonbContainerTypeName(j.val.binary.data))));
+
+	return j.val.binary.data;
+}
+
+/*
+ * Convert the STATISTICS_KIND strings defined in pg_statistic_export
+ * back to their defined enum values.
+ */
+static int16
+decode_stakind_string(char *s)
+{
+	if (strcmp(s,"MCV") == 0)
+		return STATISTIC_KIND_MCV;
+	if (strcmp(s,"HISTOGRAM") == 0)
+		return STATISTIC_KIND_HISTOGRAM;
+	if (strcmp(s,"CORRELATION") == 0)
+		return STATISTIC_KIND_CORRELATION;
+	if (strcmp(s,"MCELEM") == 0)
+		return STATISTIC_KIND_MCELEM;
+	if (strcmp(s,"DECHIST") == 0)
+		return STATISTIC_KIND_DECHIST;
+	if (strcmp(s,"RANGE_LENGTH_HISTOGRAM") == 0)
+		return STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM;
+	if (strcmp(s,"BOUNDS_HISTOGRAM") == 0)
+		return STATISTIC_KIND_BOUNDS_HISTOGRAM;
+	if (strcmp(s,"TRIVIAL") != 0)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("unknown statistics kind: %s", s)));
+
+	return 0;
+}
+
+/*
+ * examine_rel_attribute -- pre-analysis of a single column
+ *
+ * Determine whether the column is analyzable; if so, create and initialize
+ * a VacAttrStats struct for it.  If not, return NULL.
+ *
+ * If index_expr isn't NULL, then we're trying to import an expression index,
+ * and index_expr is the expression tree representing the column's data.
+ */
+VacAttrStats *
+examine_rel_attribute(Form_pg_attribute attr, Relation onerel, Node *index_expr)
+{
+	HeapTuple		typtuple;
+	int				i;
+	bool			ok;
+	VacAttrStats   *stats;
+
+	/* Never analyze dropped columns */
+	if (attr->attisdropped)
+		return NULL;
+
+	/* Don't analyze column if user has specified not to */
+	if (attr->attstattarget == 0)
+		return NULL;
+
+	/*
+	 * Create the VacAttrStats struct.
+	 */
+	stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
+	stats->attstattarget = attr->attstattarget;
+
+	/*
+	 * When analyzing an expression index, believe the expression tree's type
+	 * not the column datatype --- the latter might be the opckeytype storage
+	 * type of the opclass, which is not interesting for our purposes.  (Note:
+	 * if we did anything with non-expression index columns, we'd need to
+	 * figure out where to get the correct type info from, but for now that's
+	 * not a problem.)	It's not clear whether anyone will care about the
+	 * typmod, but we store that too just in case.
+	 */
+	if (index_expr)
+	{
+		stats->attrtypid = exprType(index_expr);
+		stats->attrtypmod = exprTypmod(index_expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(onerel->rd_indcollation[attr->attnum - 1]))
+			stats->attrcollid = onerel->rd_indcollation[attr->attnum - 1];
+		else
+			stats->attrcollid = exprCollation(index_expr);
+	}
+	else
+	{
+		stats->attrtypid = attr->atttypid;
+		stats->attrtypmod = attr->atttypmod;
+		stats->attrcollid = attr->attcollation;
+	}
+
+	typtuple = SearchSysCacheCopy1(TYPEOID,
+								   ObjectIdGetDatum(stats->attrtypid));
+	if (!HeapTupleIsValid(typtuple))
+		elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
+	stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
+	stats->anl_context = CurrentMemoryContext;
+	stats->tupattnum = attr->attnum;
+
+	/*
+	 * The fields describing the stats->stavalues[n] element types default to
+	 * the type of the data being analyzed, but the type-specific typanalyze
+	 * function can change them if it wants to store something else.
+	 */
+	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
+	{
+		stats->statypid[i] = stats->attrtypid;
+		stats->statyplen[i] = stats->attrtype->typlen;
+		stats->statypbyval[i] = stats->attrtype->typbyval;
+		stats->statypalign[i] = stats->attrtype->typalign;
+	}
+
+	/*
+	 * Call the type-specific typanalyze function.  If none is specified, use
+	 * std_typanalyze().
+	 */
+	if (OidIsValid(stats->attrtype->typanalyze))
+		ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
+										   PointerGetDatum(stats)));
+	else
+		ok = std_typanalyze(stats);
+
+	if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
+	{
+		heap_freetuple(typtuple);
+		pfree(stats);
+		return NULL;
+	}
+
+	return stats;
+}
+
+/*
+ * Import statistics (pg_statistic) into a relation
+ */
+Datum
+pg_import_rel_stats(PG_FUNCTION_ARGS)
+{
+	Oid			relid;
+	int32		stats_version_num;
+	Jsonb	   *jb;
+	Relation	rel;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("relation cannot be NULL")));
+	relid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("server_version_number cannot be NULL")));
+	stats_version_num = PG_GETARG_INT32(1);
+
+	if (stats_version_num < 80000)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics version: %d is earlier than earliest supported version",
+				  stats_version_num)));
+
+	if (PG_ARGISNULL(4))
+		jb = NULL;
+	else
+	{
+		jb = PG_GETARG_JSONB_P(4);
+		if (!JB_ROOT_IS_OBJECT(jb))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("columns must be jsonb object at root")));
+	}
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	/*
+	 * Apply statistical updates, if any, to copied tuple.
+	 *
+	 * Format is:
+	 * {
+	 *   "regular": { "columns": ..., "extended": ...},
+	 *   "inherited": { "columns": ..., "extended": ...}
+	 * }
+	 *
+	 */
+	if (jb != NULL)
+	{
+		JsonbContainer	   *cont;
+
+		cont = key_lookup_object(&jb->root, "regular");
+		import_pg_statistic(rel, false, cont);
+
+		if (rel->rd_rel->relhassubclass)
+		{
+			cont = key_lookup_object(&jb->root, "inherited");
+			import_pg_statistic(rel, true, cont);
+		}
+	}
+
+	/* only modify pg_class row if changes are to be made */
+	if ( ! PG_ARGISNULL(2) || ! PG_ARGISNULL(3) )
+	{
+		Relation		pg_class_rel;
+		HeapTuple		ctup;
+		Form_pg_class	pgcform;
+
+		/*
+		 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+		 * other stat-setting operation can run on it concurrently.
+		 */
+		pg_class_rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+		/* leave if relation could not be opened or locked */
+		if (!pg_class_rel)
+			PG_RETURN_BOOL(false);
+
+		ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+		if (!HeapTupleIsValid(ctup))
+			elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+				 relid);
+		pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+		/* leave un-set values alone */
+		if (! PG_ARGISNULL(2))
+			pgcform->reltuples = PG_GETARG_FLOAT4(2);
+		if (! PG_ARGISNULL(3))
+			pgcform->relpages = PG_GETARG_INT32(3);
+
+		heap_inplace_update(pg_class_rel, ctup);
+		table_close(pg_class_rel, ShareUpdateExclusiveLock);
+	}
+
+	/* relation_close(onerel, ShareUpdateExclusiveLock); */
+	relation_close(rel, NoLock);
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..2490472198
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,137 @@
+CREATE TYPE stats_import_complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_import_test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_import_complex_type,
+    tags text[]
+);
+INSERT INTO stats_import_test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_import_complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_import_complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_import_complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
+ANALYZE stats_import_test;
+-- capture snapshot of source stats
+CREATE TABLE stats_export AS
+SELECT e.*
+FROM pg_catalog.pg_statistic_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname IN ('stats_import_test', 'is_odd');
+SELECT c.reltuples AS before_tuples, c.relpages AS before_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ before_tuples | before_pages 
+---------------+--------------
+             4 |            1
+(1 row)
+
+-- test settting tuples and pages but no columns
+SELECT pg_import_rel_stats(c.oid,
+                           current_setting('server_version_num')::integer,
+                           1000.0, 200, NULL::jsonb)
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+SELECT c.reltuples AS after_tuples, c.relpages AS after_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+ after_tuples | after_pages 
+--------------+-------------
+         1000 |         200
+(1 row)
+
+-- create a table just like stats_import_test
+CREATE TABLE stats_import_clone ( LIKE stats_import_test );
+-- create an index just like is_odd
+CREATE INDEX is_odd2 ON stats_import_clone(((comp).a % 2 = 0));
+-- copy table stats to clone table
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN stats_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'stats_import_test'
+WHERE c.oid = 'stats_import_clone'::regclass;
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- copy index stats to clone index
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN stats_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'is_odd'
+WHERE c.oid = 'is_odd2'::regclass;
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- table stats must match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_clone'::regclass;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+-- index stats must match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'is_odd'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'is_odd2'::regclass;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+DROP TABLE stats_export;
+DROP TABLE stats_import_clone;
+DROP TABLE stats_import_test;
+DROP TYPE stats_import_complex_type;
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index f0987ff537..09ffd43fc6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..e97b9d1064
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,119 @@
+CREATE TYPE stats_import_complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_import_test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_import_complex_type,
+    tags text[]
+);
+
+INSERT INTO stats_import_test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_import_complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_import_complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_import_complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
+
+ANALYZE stats_import_test;
+
+-- capture snapshot of source stats
+CREATE TABLE stats_export AS
+SELECT e.*
+FROM pg_catalog.pg_statistic_export AS e
+WHERE e.schemaname = 'public'
+AND e.relname IN ('stats_import_test', 'is_odd');
+
+SELECT c.reltuples AS before_tuples, c.relpages AS before_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+-- test settting tuples and pages but no columns
+SELECT pg_import_rel_stats(c.oid,
+                           current_setting('server_version_num')::integer,
+                           1000.0, 200, NULL::jsonb)
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+SELECT c.reltuples AS after_tuples, c.relpages AS after_pages
+FROM pg_class AS c
+WHERE oid = 'stats_import_test'::regclass;
+
+-- create a table just like stats_import_test
+CREATE TABLE stats_import_clone ( LIKE stats_import_test );
+
+-- create an index just like is_odd
+CREATE INDEX is_odd2 ON stats_import_clone(((comp).a % 2 = 0));
+
+-- copy table stats to clone table
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN stats_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'stats_import_test'
+WHERE c.oid = 'stats_import_clone'::regclass;
+
+-- copy index stats to clone index
+SELECT pg_import_rel_stats(c.oid, e.server_version_num,
+                            e.n_tuples, e.n_pages, e.stats)
+FROM pg_class AS c
+JOIN pg_namespace AS n
+ON n.oid = c.relnamespace
+JOIN stats_export AS e
+ON e.schemaname = 'public'
+AND e.relname = 'is_odd'
+WHERE c.oid = 'is_odd2'::regclass;
+
+-- table stats must match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_test'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'stats_import_clone'::regclass;
+
+-- index stats must match
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'is_odd'::regclass
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic AS s
+WHERE s.starelid = 'is_odd2'::regclass;
+
+DROP TABLE stats_export;
+DROP TABLE stats_import_clone;
+DROP TABLE stats_import_test;
+DROP TYPE stats_import_complex_type;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 20da3ed033..ae3d1073e3 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28151,6 +28151,49 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_rel_stats</primary>
+        </indexterm>
+        <function>pg_import_rel_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>server_version_num</parameter> <type>integer</type>, <parameter>num_tuples</parameter> <type>float4</type>, <parameter>num_pages</parameter> <type>integer</type>, <parameter>column_stats</parameter> <type>jsonb</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_class</structname> row with the
+        <structfield>oid</structfield> matching <parameter>relation</parameter>
+        to set the <structfield>reltuples</structfield> and
+        <structfield>relpages</structfield> fields. This is done nontransactionally.
+        The <structname>pg_statistic</structname> rows for the
+        <structfield>statrelid</structfield> matching <parameter>relation</parameter>
+        are replaced with the values found in <parameter>column_stats</parameter>,
+        and this is done transactionally. The purpose of this function is to apply
+        statistics values in an upgrade situation that are "good enough" for system
+        operation until they are replaced by the next auto-analyze. This function
+        could be used by <program>pg_upgrade</program> and
+        <program>pg_restore</program> to convey the statistics from the old system
+        version into the new one.
+       </para></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.43.0

From bedf3ff9be5f26ed435f90e6db8405a5e7e32e67 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 12 Dec 2023 22:25:51 -0500
Subject: [PATCH v3 4/9] Add pg_export_stats, pg_import_stats.

pg_export_stats is used to export stats from databases as far back as
v10. The output is currently only to stdout and should be redirected to
a file in most use cases.

pg_import_stats is used to import stats to any version that has the
function pg_import_rel_stats().
---
 src/bin/scripts/.gitignore        |   2 +
 src/bin/scripts/Makefile          |   6 +-
 src/bin/scripts/pg_export_stats.c | 298 +++++++++++++++++++++++++++++
 src/bin/scripts/pg_import_stats.c | 303 ++++++++++++++++++++++++++++++
 4 files changed, 608 insertions(+), 1 deletion(-)
 create mode 100644 src/bin/scripts/pg_export_stats.c
 create mode 100644 src/bin/scripts/pg_import_stats.c

diff --git a/src/bin/scripts/.gitignore b/src/bin/scripts/.gitignore
index 0f23fe0004..1b9addb339 100644
--- a/src/bin/scripts/.gitignore
+++ b/src/bin/scripts/.gitignore
@@ -6,5 +6,7 @@
 /reindexdb
 /vacuumdb
 /pg_isready
+/pg_export_stats
+/pg_import_stats
 
 /tmp_check/
diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile
index 20db40b103..a019894d84 100644
--- a/src/bin/scripts/Makefile
+++ b/src/bin/scripts/Makefile
@@ -16,7 +16,7 @@ subdir = src/bin/scripts
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready
+PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready pg_export_stats pg_import_stats
 
 override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
 LDFLAGS_INTERNAL += -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport)
@@ -31,6 +31,8 @@ clusterdb: clusterdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport su
 vacuumdb: vacuumdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 reindexdb: reindexdb.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 pg_isready: pg_isready.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
+pg_export_stats: pg_export_stats.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
+pg_import_stats: pg_import_stats.o common.o $(WIN32RES) | submake-libpq submake-libpgport submake-libpgfeutils
 
 install: all installdirs
 	$(INSTALL_PROGRAM) createdb$(X)   '$(DESTDIR)$(bindir)'/createdb$(X)
@@ -41,6 +43,8 @@ install: all installdirs
 	$(INSTALL_PROGRAM) vacuumdb$(X)   '$(DESTDIR)$(bindir)'/vacuumdb$(X)
 	$(INSTALL_PROGRAM) reindexdb$(X)  '$(DESTDIR)$(bindir)'/reindexdb$(X)
 	$(INSTALL_PROGRAM) pg_isready$(X) '$(DESTDIR)$(bindir)'/pg_isready$(X)
+	$(INSTALL_PROGRAM) pg_export_stats$(X) '$(DESTDIR)$(bindir)'/pg_export_stats$(X)
+	$(INSTALL_PROGRAM) pg_import_stats$(X) '$(DESTDIR)$(bindir)'/pg_import_stats$(X)
 
 installdirs:
 	$(MKDIR_P) '$(DESTDIR)$(bindir)'
diff --git a/src/bin/scripts/pg_export_stats.c b/src/bin/scripts/pg_export_stats.c
new file mode 100644
index 0000000000..abb3659e20
--- /dev/null
+++ b/src/bin/scripts/pg_export_stats.c
@@ -0,0 +1,298 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_export_stats
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_export_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+static void help(const char *progname);
+
+/* view definition introduced in 17 */
+const char *export_query_v17 =
+	"SELECT schemaname, relname, server_version_num, n_tuples, "
+	"n_pages, stats FROM pg_statistic_export ";
+
+/*
+ * Versions 10-16 have the same stats layout, but lack the view definition,
+ * so extracting the view definition ad using it as-is will work.
+ */
+const char *export_query_v10 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    r.reltuples::float4 AS n_tuples, "
+	"    r.relpages::integer AS n_pages, "
+	"    ( "
+	"        SELECT "
+	"            jsonb_object_agg( "
+	"                CASE "
+	"                    WHEN a.stainherit THEN 'inherited' "
+	"                    ELSE 'regular' "
+	"                END, "
+	"                a.stats "
+	"            ) "
+	"        FROM "
+	"        ( "
+	"            SELECT "
+	"                s.stainherit, "
+	"                jsonb_object_agg( "
+	"                    a.attname, "
+	"                    jsonb_build_object( "
+	"                        'stanullfrac', s.stanullfrac::text, "
+	"                        'stawidth', s.stawidth::text, "
+	"                        'stadistinct', s.stadistinct::text, "
+	"                        'stakinds', "
+	"                        ( "
+	"                            SELECT "
+	"                                jsonb_agg( "
+	"                                    CASE kind.kind "
+	"                                        WHEN 0 THEN 'TRIVIAL' "
+	"                                        WHEN 1 THEN 'MCV' "
+	"                                        WHEN 2 THEN 'HISTOGRAM' "
+	"                                        WHEN 3 THEN 'CORRELATION' "
+	"                                        WHEN 4 THEN 'MCELEM' "
+	"                                        WHEN 5 THEN 'DECHIST' "
+	"                                        WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                        WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                    END::text "
+	"                                    ORDER BY kind.ord) "
+	"                            FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                        s.stakind3, stakind4, "
+	"                                        s.stakind5]) "
+	"                                 WITH ORDINALITY AS kind(kind, ord) "
+	"                        ), "
+	"                        'stanumbers', "
+	"                        jsonb_build_array( "
+	"                            s.stanumbers1::text, "
+	"                            s.stanumbers2::text, "
+	"                            s.stanumbers3::text, "
+	"                            s.stanumbers4::text, "
+	"                            s.stanumbers5::text), "
+	"                        'stavalues', "
+	"                        jsonb_build_array( "
+	"                            s.stavalues1::text, "
+	"                            s.stavalues2::text, "
+	"                            s.stavalues3::text, "
+	"                            s.stavalues4::text, "
+	"                            s.stavalues5::text) "
+	"                    ) "
+	"                ) AS stats "
+	"            FROM pg_attribute AS a "
+	"            JOIN pg_statistic AS s "
+	"                ON s.starelid = a.attrelid "
+	"                AND s.staattnum = a.attnum "
+	"            WHERE a.attrelid = r.oid "
+	"            AND NOT a.attisdropped "
+	"            AND a.attnum > 0 "
+	"            AND has_column_privilege(a.attrelid, a.attnum, 'SELECT') "
+	"            GROUP BY s.stainherit "
+	"        ) AS a "
+	"    ) AS stats "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n "
+	"    ON n.oid = r.relnamespace "
+	"WHERE relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"echo", no_argument, NULL, 'e'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		echo = false;
+
+	PQExpBufferData sql;
+
+	PGconn	   *conn;
+
+	FILE	   *copystream = stdout;
+
+	PGresult   *result;
+
+	ExecStatusType result_status;
+
+	char	   *buf;
+	int			ret;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:eh:p:U:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'e':
+				echo = true;
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, echo, false, true);
+
+	initPQExpBuffer(&sql);
+
+	appendPQExpBufferStr(&sql, "COPY (");
+
+	if (PQserverVersion(conn) >= 170000)
+		appendPQExpBufferStr(&sql, export_query_v17);
+	else if (PQserverVersion(conn) >= 100000)
+		appendPQExpBufferStr(&sql, export_query_v10);
+	else
+		pg_fatal("exporting statistics from databases prior to version 10 not supported");
+
+	appendPQExpBufferStr(&sql, ") TO STDOUT");
+
+	result = PQexec(conn, sql.data);
+	result_status = PQresultStatus(result);
+
+	if (result_status != PGRES_COPY_OUT)
+		pg_fatal("malformed copy command");
+
+	for (;;)
+	{
+		ret = PQgetCopyData(conn, &buf, 0);
+
+		if (ret < 0)
+			break;				/* done or server/connection error */
+
+		if (buf)
+		{
+			if (copystream && fwrite(buf, 1, ret, copystream) != ret)
+				pg_fatal("could not write COPY data: %m");
+			PQfreemem(buf);
+		}
+	}
+
+	if (copystream && fflush(copystream))
+		pg_fatal("could not write COPY data: %m");
+
+	if (ret == -2)
+		pg_fatal("COPY data transfer failed: %s", PQerrorMessage(conn));
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -e, --echo                show the commands being sent to the server\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
diff --git a/src/bin/scripts/pg_import_stats.c b/src/bin/scripts/pg_import_stats.c
new file mode 100644
index 0000000000..122afc0971
--- /dev/null
+++ b/src/bin/scripts/pg_import_stats.c
@@ -0,0 +1,303 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_import_stats
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_import_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+#define COPY_BUF_LEN 8192
+
+static void help(const char *progname);
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"quiet", no_argument, NULL, 'q'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		quiet = false;
+
+	PGconn	   *conn;
+
+	FILE	   *copysrc= stdin;
+
+	PGresult   *result;
+
+	int		i;
+	int		numtables;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:h:p:qU:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'q':
+				quiet = true;
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, false, false, true);
+
+	/* open file */
+
+	/* iterate over records */
+
+
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_stats ( "
+		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
+		"schemaname text, relname text, server_version_num integer, "
+		"n_tuples float4, n_pages integer, stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary file: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	result = PQexec(conn,
+		"COPY import_stats(schemaname, relname, server_version_num, n_tuples, "
+		"n_pages, stats) FROM STDIN");
+
+	if (PQresultStatus(result) != PGRES_COPY_IN)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	for (;;)
+	{
+		char copybuf[COPY_BUF_LEN];
+
+		int numread = fread(copybuf, 1, COPY_BUF_LEN, copysrc);
+
+		if (ferror(copysrc))
+			pg_fatal("error reading from source");
+
+		if (numread == 0)
+			break;
+
+		if (PQputCopyData(conn, copybuf, numread) == -1)
+			pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	}
+
+	if (PQputCopyEnd(conn, NULL) == -1)
+		pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	fclose(copysrc);
+
+	result = PQgetResult(conn);
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	numtables = atol(PQcmdTuples(result));
+
+	PQclear(result);
+
+	result = PQprepare(conn, "import",
+		"SELECT pg_import_rel_stats(c.oid, s.server_version_num, "
+		"             s.n_tuples, s.n_pages, s.stats) as import_result "
+		"FROM import_stats AS s "
+		"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+		"JOIN pg_class AS c ON c.relnamespace = n.oid "
+		"                   AND c.relname = s.relname "
+		"WHERE s.id = $1::bigint ",
+		1, NULL);
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	if (!quiet)
+	{
+		result = PQprepare(conn, "echo",
+			"SELECT s.schemaname, s.relname "
+			"FROM import_stats AS s "
+			"WHERE s.id = $1::bigint ",
+			1, NULL);
+
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+		PQclear(result);
+	}
+
+	for (i = 1; i <= numtables; i++)
+	{
+		char	istr[32];
+		char   *schema = NULL;
+		char   *table = NULL;
+
+		const char *const values[] = {istr};
+
+		snprintf(istr, 32, "%d", i);
+
+		if (!quiet)
+		{
+			result = PQexecPrepared(conn, "echo", 1, values, NULL, NULL, 0);
+			schema = pg_strdup(PQgetvalue(result, 0, 0));
+			table = pg_strdup(PQgetvalue(result, 0, 1));
+		}
+
+		PQclear(result);
+
+		result = PQexecPrepared(conn, "import", 1, values, NULL, NULL, 0);
+
+		if (quiet)
+		{
+			PQclear(result);
+			continue;
+		}
+
+		if (PQresultStatus(result) == PGRES_TUPLES_OK)
+		{
+			int 	rows = PQntuples(result);
+
+			if (rows == 1)
+			{
+				char   *retval = PQgetvalue(result, 0, 0);
+				if (*retval == 't')
+					printf("%s.%s: imported\n", schema, table);
+				else
+					printf("%s.%s: failed\n", schema, table);
+			}
+			else if (rows == 0)
+				printf("%s.%s: not found\n", schema, table);
+			else
+				pg_fatal("import function must return 0 or 1 rows");
+		}
+		else
+			printf("%s.%s: error: %s\n", schema, table, PQerrorMessage(conn));
+
+		if (schema != NULL)
+			pfree(schema);
+
+		if (table != NULL)
+			pfree(table);
+
+		PQclear(result);
+	}
+
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -q, --quiet               don't write any messages\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
-- 
2.43.0

From 059494d82745258400a145b6aa71ce958f23347a Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 9 Dec 2023 04:59:23 -0500
Subject: [PATCH v3 5/9] Add system view pg_statistic_ext_export.

This view is designed to aid in the export (and re-import) of extended
statistics, mostly for upgrade/restore situations.
---
 src/backend/catalog/system_views.sql | 131 +++++++++++++++++++++++++++
 src/test/regress/expected/rules.out  |  34 +++++++
 doc/src/sgml/system-views.sgml       |   5 +
 3 files changed, 170 insertions(+)

diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 7655bf7458..8dca87c061 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -356,6 +356,137 @@ CREATE VIEW pg_statistic_export WITH (security_barrier) AS
     WHERE relkind IN ('r', 'm', 'f', 'p', 'i')
     AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema');
 
+CREATE VIEW pg_statistic_ext_export WITH (security_barrier) AS
+    SELECT
+        n.nspname AS schemaname,
+        r.relname AS tablename,
+        e.stxname AS ext_stats_name,
+        (current_setting('server_version_num'::text))::integer AS server_version_num,
+        jsonb_object_agg(
+            CASE sd.stxdinherit
+                WHEN true THEN 'inherited'
+                ELSE 'regular'
+            END,
+            jsonb_build_object(
+                'stxkinds',
+                to_jsonb(e.stxkind),
+                'stxdndistinct',
+                (
+                    SELECT
+                        jsonb_agg(
+                            -- att1, [, att2 ...] => attN: degree
+                            jsonb_build_object(
+                                'attnums',
+                                string_to_array(nd.attnums, ', '::text),
+                                'ndistinct',
+                                nd.ndistinct
+                                )
+                            ORDER BY nd.ord
+                        )
+                    -- jsonb does not preserve parsed order so use json
+                    FROM json_each_text(sd.stxdndistinct::text::json)
+                        WITH ORDINALITY AS nd(attnums, ndistinct, ord)
+                    WHERE sd.stxdndistinct IS NOT NULL
+                ),
+                'stxdndependencies',
+                (
+                    SELECT
+                        jsonb_agg(
+                            jsonb_build_object(
+                                'attnums',
+                                string_to_array(
+                                    replace(dep.attrs, ' => ', ', '), ', '
+                                ),
+                                'degree',
+                                dep.degree
+                            )
+                            ORDER BY dep.ord
+                        )
+                    FROM json_each_text(sd.stxddependencies::text::json)
+                        WITH ORDINALITY AS dep(attrs, degree, ord)
+                    WHERE sd.stxddependencies IS NOT NULL
+                ),
+                'stxdmcv',
+                (
+                    SELECT
+                        jsonb_agg(
+                            jsonb_build_object(
+                                'index',
+                                mcvl.index::text,
+                                'frequency',
+                                mcvl.frequency::text,
+                                'base_frequency',
+                                mcvl.base_frequency::text,
+                                'values',
+                                mcvl.values,
+                                'nulls',
+                                mcvl.nulls
+                            )
+                        )
+                    FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                    WHERE sd.stxdmcv IS NOT NULL
+                ),
+                'stxdexprs',
+                (
+                    SELECT
+                        jsonb_agg(
+                            jsonb_build_object(
+                                'stanullfrac',
+                                s.stanullfrac::text,
+                                'stawidth',
+                                s.stawidth::text,
+                                'stadistinct',
+                                s.stadistinct::text,
+                                'stakinds',
+                                (
+                                    SELECT
+                                        jsonb_agg(
+                                            CASE kind.kind
+                                                WHEN 0 THEN 'TRIVIAL'
+                                                WHEN 1 THEN 'MCV'
+                                                WHEN 2 THEN 'HISTOGRAM'
+                                                WHEN 3 THEN 'CORRELATION'
+                                                WHEN 4 THEN 'MCELEM'
+                                                WHEN 5 THEN 'DECHIST'
+                                                WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'
+                                                WHEN 7 THEN 'BOUNDS_HISTOGRAM'
+                                                ELSE NULL
+                                            END
+                                            ORDER BY kind.ord
+                                        )
+                                    FROM unnest(ARRAY[s.stakind1, s.stakind2,
+                                                      s.stakind3, s.stakind4,
+                                                      s.stakind5])
+                                        WITH ORDINALITY kind(kind, ord)
+                                ),
+                                'stanumbers',
+                                jsonb_build_array(
+                                    s.stanumbers1::text,
+                                    s.stanumbers2::text,
+                                    s.stanumbers3::text,
+                                    s.stanumbers4::text,
+                                    s.stanumbers5::text
+                                ),
+                                'stavalues',
+                                jsonb_build_array(
+                                    s.stavalues1::text,
+                                    s.stavalues2::text,
+                                    s.stavalues3::text,
+                                    s.stavalues4::text,
+                                    s.stavalues5::text)
+                                )
+                                ORDER BY s.ordinality
+                            )
+                    FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s
+                    WHERE sd.stxdexpr IS NOT NULL
+                )
+            )
+        ) AS stats
+    FROM pg_class r
+    JOIN pg_namespace n ON n.oid = r.relnamespace
+    JOIN pg_statistic_ext e ON e.stxrelid = r.oid
+    JOIN pg_statistic_ext_data sd ON sd.stxoid = e.oid
+    GROUP BY schemaname, tablename, ext_stats_name, server_version_num;
 
 
 CREATE VIEW pg_stats_ext WITH (security_barrier) AS
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index f2b059af5e..66ebac6cfd 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -2435,6 +2435,40 @@ pg_statistic_export| SELECT n.nspname AS schemaname,
    FROM (pg_class r
      JOIN pg_namespace n ON ((n.oid = r.relnamespace)))
   WHERE ((r.relkind = ANY (ARRAY['r'::"char", 'm'::"char", 'f'::"char", 'p'::"char", 'i'::"char"])) AND (n.nspname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name])));
+pg_statistic_ext_export| SELECT n.nspname AS schemaname,
+    r.relname AS tablename,
+    e.stxname AS ext_stats_name,
+    (current_setting('server_version_num'::text))::integer AS server_version_num,
+    jsonb_object_agg(
+        CASE sd.stxdinherit
+            WHEN true THEN 'inherited'::text
+            ELSE 'regular'::text
+        END, jsonb_build_object('stxkinds', to_jsonb(e.stxkind), 'stxdndistinct', ( SELECT jsonb_agg(jsonb_build_object('attnums', string_to_array(nd.attnums, ', '::text), 'ndistinct', nd.ndistinct) ORDER BY nd.ord) AS jsonb_agg
+           FROM json_each_text(((sd.stxdndistinct)::text)::json) WITH ORDINALITY nd(attnums, ndistinct, ord)
+          WHERE (sd.stxdndistinct IS NOT NULL)), 'stxdndependencies', ( SELECT jsonb_agg(jsonb_build_object('attnums', string_to_array(replace(dep.attrs, ' => '::text, ', '::text), ', '::text), 'degree', dep.degree) ORDER BY dep.ord) AS jsonb_agg
+           FROM json_each_text(((sd.stxddependencies)::text)::json) WITH ORDINALITY dep(attrs, degree, ord)
+          WHERE (sd.stxddependencies IS NOT NULL)), 'stxdmcv', ( SELECT jsonb_agg(jsonb_build_object('index', (mcvl.index)::text, 'frequency', (mcvl.frequency)::text, 'base_frequency', (mcvl.base_frequency)::text, 'values', mcvl."values", 'nulls', mcvl.nulls)) AS jsonb_agg
+           FROM pg_mcv_list_items(sd.stxdmcv) mcvl(index, "values", nulls, frequency, base_frequency)
+          WHERE (sd.stxdmcv IS NOT NULL)), 'stxdexprs', ( SELECT jsonb_agg(jsonb_build_object('stanullfrac', (s.stanullfrac)::text, 'stawidth', (s.stawidth)::text, 'stadistinct', (s.stadistinct)::text, 'stakinds', ( SELECT jsonb_agg(
+                        CASE kind.kind
+                            WHEN 0 THEN 'TRIVIAL'::text
+                            WHEN 1 THEN 'MCV'::text
+                            WHEN 2 THEN 'HISTOGRAM'::text
+                            WHEN 3 THEN 'CORRELATION'::text
+                            WHEN 4 THEN 'MCELEM'::text
+                            WHEN 5 THEN 'DECHIST'::text
+                            WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM'::text
+                            WHEN 7 THEN 'BOUNDS_HISTOGRAM'::text
+                            ELSE NULL::text
+                        END ORDER BY kind.ord) AS jsonb_agg
+                   FROM unnest(ARRAY[s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5]) WITH ORDINALITY kind(kind, ord)), 'stanumbers', jsonb_build_array((s.stanumbers1)::text, (s.stanumbers2)::text, (s.stanumbers3)::text, (s.stanumbers4)::text, (s.stanumbers5)::text), 'stavalues', jsonb_build_array((s.stavalues1)::text, (s.stavalues2)::text, (s.stavalues3)::text, (s.stavalues4)::text, (s.stavalues5)::text)) ORDER BY s.ordinality) AS jsonb_agg
+           FROM unnest(sd.stxdexpr) WITH ORDINALITY s(starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5, ordinality)
+          WHERE (sd.stxdexpr IS NOT NULL)))) AS stats
+   FROM (((pg_class r
+     JOIN pg_namespace n ON ((n.oid = r.relnamespace)))
+     JOIN pg_statistic_ext e ON ((e.stxrelid = r.oid)))
+     JOIN pg_statistic_ext_data sd ON ((sd.stxoid = e.oid)))
+  GROUP BY n.nspname, r.relname, e.stxname, (current_setting('server_version_num'::text))::integer;
 pg_stats| SELECT n.nspname AS schemaname,
     c.relname AS tablename,
     a.attname,
diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml
index 91b3ab22fb..af5dff6a74 100644
--- a/doc/src/sgml/system-views.sgml
+++ b/doc/src/sgml/system-views.sgml
@@ -196,6 +196,11 @@
       <entry>planner statistics for export/upgrade purposes</entry>
      </row>
 
+     <row>
+      <entry><link linkend="view-pg-stats-ext"><structname>pg_stats_ext_export</structname></link></entry>
+      <entry>extended planner statistics for export/upgrade purposes</entry>
+     </row>
+
      <row>
       <entry><link linkend="view-pg-tables"><structname>pg_tables</structname></link></entry>
       <entry>tables</entry>
-- 
2.43.0

From 0797a698495c21baaef3b633e78425bcd7b16821 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Mon, 11 Dec 2023 03:23:28 -0500
Subject: [PATCH v3 6/9] Create create_stat_ext_entry() from
 fetch_statentries_for_relation().

Refactor fetch_statentries_for_relation() to use create_stat_ext_entry() in
its inner loop.

Later commits will make use of create_stat_ext_entry().

This was made its own commit for code clarity.
---
 src/backend/statistics/extended_stats.c | 146 +++++++++++++-----------
 1 file changed, 78 insertions(+), 68 deletions(-)

diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index 7f014a0cbb..718826ecf1 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -418,6 +418,83 @@ statext_is_kind_built(HeapTuple htup, char type)
 	return !heap_attisnull(htup, attnum, NULL);
 }
 
+/*
+ * Create a single StatExtEntry from a fetched heap tuple
+ */
+static StatExtEntry *
+create_stat_ext_entry(HeapTuple htup)
+{
+	StatExtEntry *entry;
+	Datum		datum;
+	bool		isnull;
+	int			i;
+	ArrayType  *arr;
+	char	   *enabled;
+	Form_pg_statistic_ext staForm;
+	List	   *exprs = NIL;
+
+	entry = palloc0(sizeof(StatExtEntry));
+	staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
+	entry->statOid = staForm->oid;
+	entry->schema = get_namespace_name(staForm->stxnamespace);
+	entry->name = pstrdup(NameStr(staForm->stxname));
+	entry->stattarget = staForm->stxstattarget;
+	for (i = 0; i < staForm->stxkeys.dim1; i++)
+	{
+		entry->columns = bms_add_member(entry->columns,
+										staForm->stxkeys.values[i]);
+	}
+
+	/* decode the stxkind char array into a list of chars */
+	datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
+								   Anum_pg_statistic_ext_stxkind);
+	arr = DatumGetArrayTypeP(datum);
+	if (ARR_NDIM(arr) != 1 ||
+		ARR_HASNULL(arr) ||
+		ARR_ELEMTYPE(arr) != CHAROID)
+		elog(ERROR, "stxkind is not a 1-D char array");
+	enabled = (char *) ARR_DATA_PTR(arr);
+	for (i = 0; i < ARR_DIMS(arr)[0]; i++)
+	{
+		Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
+			   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
+			   (enabled[i] == STATS_EXT_MCV) ||
+			   (enabled[i] == STATS_EXT_EXPRESSIONS));
+		entry->types = lappend_int(entry->types, (int) enabled[i]);
+	}
+
+	/* decode expression (if any) */
+	datum = SysCacheGetAttr(STATEXTOID, htup,
+							Anum_pg_statistic_ext_stxexprs, &isnull);
+
+	if (!isnull)
+	{
+		char	   *exprsString;
+
+		exprsString = TextDatumGetCString(datum);
+		exprs = (List *) stringToNode(exprsString);
+
+		pfree(exprsString);
+
+		/*
+		 * Run the expressions through eval_const_expressions. This is not
+		 * just an optimization, but is necessary, because the planner
+		 * will be comparing them to similarly-processed qual clauses, and
+		 * may fail to detect valid matches without this.  We must not use
+		 * canonicalize_qual, however, since these aren't qual
+		 * expressions.
+		 */
+		exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
+
+		/* May as well fix opfuncids too */
+		fix_opfuncids((Node *) exprs);
+	}
+
+	entry->exprs = exprs;
+
+	return entry;
+}
+
 /*
  * Return a list (of StatExtEntry) of statistics objects for the given relation.
  */
@@ -443,74 +520,7 @@ fetch_statentries_for_relation(Relation pg_statext, Oid relid)
 
 	while (HeapTupleIsValid(htup = systable_getnext(scan)))
 	{
-		StatExtEntry *entry;
-		Datum		datum;
-		bool		isnull;
-		int			i;
-		ArrayType  *arr;
-		char	   *enabled;
-		Form_pg_statistic_ext staForm;
-		List	   *exprs = NIL;
-
-		entry = palloc0(sizeof(StatExtEntry));
-		staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
-		entry->statOid = staForm->oid;
-		entry->schema = get_namespace_name(staForm->stxnamespace);
-		entry->name = pstrdup(NameStr(staForm->stxname));
-		entry->stattarget = staForm->stxstattarget;
-		for (i = 0; i < staForm->stxkeys.dim1; i++)
-		{
-			entry->columns = bms_add_member(entry->columns,
-											staForm->stxkeys.values[i]);
-		}
-
-		/* decode the stxkind char array into a list of chars */
-		datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
-									   Anum_pg_statistic_ext_stxkind);
-		arr = DatumGetArrayTypeP(datum);
-		if (ARR_NDIM(arr) != 1 ||
-			ARR_HASNULL(arr) ||
-			ARR_ELEMTYPE(arr) != CHAROID)
-			elog(ERROR, "stxkind is not a 1-D char array");
-		enabled = (char *) ARR_DATA_PTR(arr);
-		for (i = 0; i < ARR_DIMS(arr)[0]; i++)
-		{
-			Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
-				   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
-				   (enabled[i] == STATS_EXT_MCV) ||
-				   (enabled[i] == STATS_EXT_EXPRESSIONS));
-			entry->types = lappend_int(entry->types, (int) enabled[i]);
-		}
-
-		/* decode expression (if any) */
-		datum = SysCacheGetAttr(STATEXTOID, htup,
-								Anum_pg_statistic_ext_stxexprs, &isnull);
-
-		if (!isnull)
-		{
-			char	   *exprsString;
-
-			exprsString = TextDatumGetCString(datum);
-			exprs = (List *) stringToNode(exprsString);
-
-			pfree(exprsString);
-
-			/*
-			 * Run the expressions through eval_const_expressions. This is not
-			 * just an optimization, but is necessary, because the planner
-			 * will be comparing them to similarly-processed qual clauses, and
-			 * may fail to detect valid matches without this.  We must not use
-			 * canonicalize_qual, however, since these aren't qual
-			 * expressions.
-			 */
-			exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
-
-			/* May as well fix opfuncids too */
-			fix_opfuncids((Node *) exprs);
-		}
-
-		entry->exprs = exprs;
-
+		StatExtEntry *entry = create_stat_ext_entry(htup);
 		result = lappend(result, entry);
 	}
 
-- 
2.43.0

From 0bfed151e366b2e0389356613713ae33d859382e Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Wed, 13 Dec 2023 04:00:47 -0500
Subject: [PATCH v3 8/9] Allow explicit nulls in container lookups.

Allow key_lookup_object() and key_lookup_array() to treat explicit JSONB
jbvNull values the same as if the key were omitted entirely.

This allows export functions to create the keyed object via a query
without worrying about removing the key if there is no underlying data.

Also, having a key existing with an affirmative "there is no data here"
is more clear than the key missing.
---
 src/backend/statistics/statistics.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
index e54f1c9162..b1f0396d47 100644
--- a/src/backend/statistics/statistics.c
+++ b/src/backend/statistics/statistics.c
@@ -528,16 +528,19 @@ JsonbContainer *key_lookup_object(JsonbContainer *cont, const char *key)
 	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
 		return NULL;
 
+	if (j.type == jbvNull)
+		return NULL;
+
 	if (j.type != jbvBinary)
 		ereport(ERROR,
 		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-		   errmsg("invalid statistics format, %s must be an object but is type %s",
+		   errmsg("invalid statistics format, %s must be an object or null but is type %s",
 				  key, JsonbTypeName(&j))));
 
 	if (!JsonContainerIsObject(j.val.binary.data))
 		ereport(ERROR,
 		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-		   errmsg("invalid statistics format, %s must be an object but is type %s",
+		   errmsg("invalid statistics format, %s must be an object or null but is type %s",
 				  key, JsonbContainerTypeName(j.val.binary.data))));
 
 	return j.val.binary.data;
@@ -553,16 +556,19 @@ JsonbContainer *key_lookup_array(JsonbContainer *cont, const char *key)
 	if (!getKeyJsonValueFromContainer(cont, key, strlen(key), &j))
 		return NULL;
 
+	if (j.type == jbvNull)
+		return NULL;
+
 	if (j.type != jbvBinary)
 		ereport(ERROR,
 		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-		   errmsg("invalid statistics format, %s must be an array but is type %s",
+		   errmsg("invalid statistics format, %s must be an array or null but is type %s",
 				  key, JsonbTypeName(&j))));
 
 	if (!JsonContainerIsArray(j.val.binary.data))
 		ereport(ERROR,
 		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-		   errmsg("invalid statistics format, %s must be an array but is type %s",
+		   errmsg("invalid statistics format, %s must be an array or null but is type %s",
 				  key, JsonbContainerTypeName(j.val.binary.data))));
 
 	return j.val.binary.data;
-- 
2.43.0

From 159763cbf70b11675321fb56a00e5ea1a8e4592b Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Wed, 13 Dec 2023 03:55:35 -0500
Subject: [PATCH v3 7/9] Add pg_import_ext_stats()

This is the extended statistics equivalent of pg_import_rel_stats().

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a best-effort approach, skipping statistics that are
expected but omitted, skipping object that are specified but do not
exist on the target system. The goal is to get better-than-empty
statistics into the STATISTICS object quickly, so that business
operations can resume sooner. The statistics generated will replace
existing rows in pg_statistic_ext_data for the same statistics
object, and this is done in an all-or-nothing basis rather than
attempting to modify existing rows.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

The medium of exchange is jsonb, the format of which is specified in the
view pg_statistic_ext_export. Obviously this view does not exist in older
versions of the database, but the view definition can be extracted and
adapted to older versions.

This function also allows for tweaking of table statistics in-place,
allowing the user to simulate correlations, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   5 +
 .../statistics/extended_stats_internal.h      |   8 +-
 src/backend/statistics/dependencies.c         | 111 +++++++
 src/backend/statistics/extended_stats.c       | 291 ++++++++++++++++++
 src/backend/statistics/mcv.c                  | 217 ++++++++++++-
 src/backend/statistics/mvdistinct.c           | 101 ++++++
 src/backend/statistics/statistics.c           |   8 +-
 .../regress/expected/stats_export_import.out  |  20 ++
 src/test/regress/sql/stats_export_import.sql  |  18 ++
 doc/src/sgml/func.sgml                        |  21 ++
 10 files changed, 794 insertions(+), 6 deletions(-)

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 4d1e9bde1f..bd674e232e 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5660,6 +5660,11 @@
   proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
   proparallel => 'u', prorettype => 'bool', proargtypes => 'oid int4 float4 int4 jsonb',
   prosrc => 'pg_import_rel_stats' },
+{ oid => '9162',
+  descr => 'statistics: import to extended stats object',
+  proname => 'pg_import_ext_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid int4 jsonb',
+  prosrc => 'pg_import_ext_stats' },
 { oid => '3150', descr => 'statistics: number of temporary files written',
   proname => 'pg_stat_get_db_temp_files', provolatile => 's',
   proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
diff --git a/src/include/statistics/extended_stats_internal.h b/src/include/statistics/extended_stats_internal.h
index 7b55eb8ffa..5fb4523525 100644
--- a/src/include/statistics/extended_stats_internal.h
+++ b/src/include/statistics/extended_stats_internal.h
@@ -68,17 +68,21 @@ typedef struct StatsBuildData
 	bool	  **nulls;
 } StatsBuildData;
 
-
 extern MVNDistinct *statext_ndistinct_build(double totalrows, StatsBuildData *data);
+extern MVNDistinct *statext_ndistinct_import(JsonbContainer *cont);
 extern bytea *statext_ndistinct_serialize(MVNDistinct *ndistinct);
 extern MVNDistinct *statext_ndistinct_deserialize(bytea *data);
 
 extern MVDependencies *statext_dependencies_build(StatsBuildData *data);
+extern MVDependencies *statext_dependencies_import(JsonbContainer *cont);
 extern bytea *statext_dependencies_serialize(MVDependencies *dependencies);
 extern MVDependencies *statext_dependencies_deserialize(bytea *data);
+extern bytea *import_dependencies(JsonbContainer *cont);
 
 extern MCVList *statext_mcv_build(StatsBuildData *data,
 								  double totalrows, int stattarget);
+extern MCVList *statext_mcv_import(JsonbContainer *cont,
+									VacAttrStats **stats, int natts);
 extern bytea *statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats);
 extern MCVList *statext_mcv_deserialize(bytea *data);
 
@@ -127,4 +131,6 @@ extern Selectivity mcv_clause_selectivity_or(PlannerInfo *root,
 											 Selectivity *overlap_basesel,
 											 Selectivity *totalsel);
 
+extern Datum pg_import_ext_stats(PG_FUNCTION_ARGS);
+
 #endif							/* EXTENDED_STATS_INTERNAL_H */
diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c
index edb2e5347d..ca8b20adab 100644
--- a/src/backend/statistics/dependencies.c
+++ b/src/backend/statistics/dependencies.c
@@ -27,7 +27,9 @@
 #include "parser/parsetree.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/bytea.h"
+#include "utils/float.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
@@ -1829,3 +1831,112 @@ dependencies_clauselist_selectivity(PlannerInfo *root,
 
 	return s1;
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * Like statext_dependencies_build, but import the data
+ * from a JSON object.
+ *
+ * import format:
+ * [
+ *   {
+ *     "attnums": [ intstr, ... ],
+ *     "degree": floatstr
+ *   }
+ * ]
+ *
+ */
+MVDependencies *
+statext_dependencies_import(JsonbContainer *cont)
+{
+	MVDependencies *dependencies = NULL;
+	int				ndeps;
+	int				i;
+
+
+	if (cont == NULL)
+		ndeps = 0;
+	else
+		ndeps = JsonContainerSize(cont);
+
+	if (ndeps == 0)
+		dependencies = (MVDependencies *) palloc0(sizeof(MVDependencies));
+	else
+		dependencies = (MVDependencies *) palloc0(offsetof(MVDependencies, deps)
+												   + (ndeps * sizeof(MVDependency *)));
+
+	dependencies->magic = STATS_DEPS_MAGIC;
+	dependencies->type = STATS_DEPS_TYPE_BASIC;
+	dependencies->ndeps = ndeps;
+
+	/* compute length of output */
+	for (i = 0; i < ndeps; i++)
+	{
+		JsonbValue	   *j;
+		JsonbContainer *elemobj,
+					   *attnumarr;
+		MVDependency   *d;
+		char		   *s;
+		int				a;
+		int				natts;
+
+		j = getIthJsonbValueFromContainer(cont, i);
+
+		if ((j == NULL)
+				|| (j->type != jbvBinary)
+				|| (!JsonContainerIsObject(j->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdepndencies "
+					  "must be objects.")));
+
+		elemobj = j->val.binary.data;
+		attnumarr = key_lookup_array(elemobj, "attnums");
+
+		if (attnumarr == NULL)
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdependencies "
+					  "must contain an element called attnums which is an array.")));
+
+		natts = JsonContainerSize(attnumarr);
+		d = (MVDependency *) palloc0(offsetof(MVDependency, attributes)
+									 + (natts * sizeof(AttrNumber)));
+		dependencies->deps[i] = d;
+
+		d->nattributes = natts;
+
+		s = key_lookup_cstring(elemobj, "degree");
+		if (s != NULL)
+		{
+			d->degree = float8in_internal(s, NULL, "double", s, NULL);
+			pfree(s);
+		}
+		else
+			d->degree = 0;
+
+		for (a = 0; a < natts; a++)
+		{
+			JsonbValue *aj;
+			char	   *str;
+
+			aj = getIthJsonbValueFromContainer(attnumarr, a);
+
+			if ((aj == NULL) || (aj->type != jbvString))
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, elements of attnums "
+						  "must be string representations of integers.")));
+
+			str = JsonbStringValueToCString(aj);
+			d->attributes[a] = pg_strtoint16(str);
+			pfree(str);
+			pfree(aj);
+		}
+
+		pfree(j);
+	}
+
+	return dependencies;
+}
diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index 718826ecf1..69072485fa 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -19,6 +19,7 @@
 #include "access/detoast.h"
 #include "access/genam.h"
 #include "access/htup_details.h"
+#include "access/relation.h"
 #include "access/table.h"
 #include "catalog/indexing.h"
 #include "catalog/pg_collation.h"
@@ -495,6 +496,38 @@ create_stat_ext_entry(HeapTuple htup)
 	return entry;
 }
 
+/*
+ * Return a list (of StatExtEntry) of statistics objects for the given relation.
+ */
+/* TODO needed????
+static StatExtEntry *
+fetch_statentry(Relation pg_statext, Oid stxid)
+{
+	SysScanDesc scan;
+	ScanKeyData skey;
+	HeapTuple	htup;
+	StatExtEntry *entry = NULL;
+
+	/-*
+	 * Prepare to scan pg_statistic_ext for entries having given oid.
+	 *-/
+	ScanKeyInit(&skey,
+				Anum_pg_statistic_ext_oid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(stxid));
+
+	scan = systable_beginscan(pg_statext, StatisticExtRelidIndexId, true,
+							  NULL, 1, &skey);
+
+	if (HeapTupleIsValid(htup = systable_getnext(scan)))
+		entry = create_stat_ext_entry(htup);
+
+	systable_endscan(scan);
+
+	return entry;
+}
+*/
+
 /*
  * Return a list (of StatExtEntry) of statistics objects for the given relation.
  */
@@ -2421,6 +2454,8 @@ serialize_expr_stats(AnlExprData *exprdata, int nexprs)
 								  false,
 								  typOid,
 								  CurrentMemoryContext);
+
+		heap_freetuple(stup);
 	}
 
 	table_close(sd, RowExclusiveLock);
@@ -2646,3 +2681,259 @@ make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
 
 	return result;
 }
+
+/*
+ * Generate VacAttrStats for a single pg_statistic_ext
+ */
+static VacAttrStats **
+examine_ext_stat_types(StatExtEntry *stxentry, Relation rel)
+{
+	TupleDesc		tupdesc = RelationGetDescr(rel);
+	Bitmapset	   *columns = stxentry->columns;
+	List		   *exprs = stxentry->exprs;
+	int				natts = bms_num_members(columns) + list_length(exprs);
+	int				i = 0;
+	int				m = -1;
+
+	VacAttrStats  **stats;
+	ListCell   *lc;
+
+	stats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
+
+	/* lookup VacAttrStats info for the requested columns (same attnum) */
+	while ((m = bms_next_member(columns, m)) >= 0)
+	{
+		Form_pg_attribute	attform = TupleDescAttr(tupdesc, m - 1);
+
+		stats[i] = examine_rel_attribute(attform, rel, NULL);
+
+		/* ext expr stats remove the tupattnum */
+		stats[i]->tupattnum = InvalidAttrNumber;
+		i++;
+	}
+
+	/* also add info for expressions */
+	foreach(lc, exprs)
+	{
+		Node	   *expr = (Node *) lfirst(lc);
+
+		stats[i] = examine_attribute(expr);
+		i++;
+	}
+
+	return stats;
+}
+
+/*
+ * Generate expressions from imported data.
+ */
+static Datum
+import_expressions(Relation rel, JsonbContainer *cont,
+					VacAttrStats **expr_stats, int nexprs)
+{
+	int			i;
+	int			nelems;
+	Oid			typOid;
+	Relation	sd;
+
+	ArrayBuildState *astate = NULL;
+
+	/* skip if no stats to import */
+	if (cont == NULL)
+		return (Datum) 0;
+
+	nelems = JsonContainerSize(cont);
+
+	if (nelems == 0)
+		return (Datum) 0;
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/* lookup OID of composite type for pg_statistic */
+	typOid = get_rel_type_id(StatisticRelationId);
+	if (!OidIsValid(typOid))
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("relation \"%s\" does not have a composite type",
+						"pg_statistic")));
+
+	/*
+	 * The number of elements should not exceed the number of columns in the
+	 * extended statistics object. The elements should follow the same order
+	 * as they do on disk: regular attributes first, followed by expressions.
+	 * TODO make this a warning
+	 */
+	if (nelems > nexprs)
+	{
+		nelems = nexprs;
+	}
+	nelems = Min(nelems, nexprs);
+
+	for (i = 0; i < nelems; i++)
+	{
+		Datum		values[Natts_pg_statistic] = { 0 };
+		bool		nulls[Natts_pg_statistic] = { false };
+		bool		replaces[Natts_pg_statistic] = { false };
+		HeapTuple	stup;
+
+		JsonbValue   *j = getIthJsonbValueFromContainer(cont, i);
+		VacAttrStats *stat = expr_stats[i];
+
+		JsonbContainer *exprobj;
+
+		if ((j == NULL)
+				|| (j->type != jbvBinary)
+				|| (!JsonContainerIsObject(j->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdexprs "
+					  "must be objects.")));
+
+		exprobj = j->val.binary.data;
+
+		import_attribute(InvalidOid, stat, exprobj, false, values, nulls, replaces);
+
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+
+		astate = accumArrayResult(astate,
+								  heap_copy_tuple_as_datum(stup, RelationGetDescr(sd)),
+								  false,
+								  typOid,
+								  CurrentMemoryContext);
+		pfree(j);
+	}
+
+	table_close(sd, RowExclusiveLock);
+
+	return makeArrayResult(astate, CurrentMemoryContext);
+}
+
+/*
+ * import_pg_ext_stats
+ *
+ * Import stats for one aspect (inherited / regular) of an Extended Statistics
+ * object.
+ *
+ * The JSON container should look like this:
+ * {
+ *     "stxkinds": array of single characters (up to 3?),
+ *     "stxdndistinct": [ {ndistinct}, ... ],
+ *     "stxdndependencies": [ {dependency}, ... ]
+ *     "stxdmcv": [ {mcv}, ... ]
+ *     "stxdexprs" : [ {pg_statistic}, ... ]
+ * }
+ */
+static void
+import_pg_statistic_ext_data(StatExtEntry *stxentry, Relation rel,
+							 bool inh, JsonbContainer *cont,
+							 VacAttrStats **stats)
+{
+	int				ncols;
+	int				nexprs;
+	int				natts;
+	VacAttrStats  **expr_stats;
+
+	JsonbContainer *arraycont;
+	MCVList		   *mcvlist;
+	MVDependencies *dependencies;
+	MVNDistinct	   *ndistinct;
+	Datum			exprs;
+
+	/* skip if no stats to import */
+	if (cont == NULL)
+		return;
+
+	ncols = bms_num_members(stxentry->columns);
+	nexprs = list_length(stxentry->exprs);
+	natts = ncols + nexprs;
+	expr_stats = &stats[ncols];
+
+	arraycont = key_lookup_array(cont, "stxdndistinct");
+	ndistinct = statext_ndistinct_import(arraycont);
+
+	arraycont = key_lookup_array(cont, "stxdndependencies");
+	dependencies = statext_dependencies_import(arraycont);
+
+	arraycont = key_lookup_array(cont, "stxdmcv");
+	mcvlist = statext_mcv_import(arraycont, stats, natts);
+
+	arraycont = key_lookup_array(cont, "stxdexprs");
+	exprs = import_expressions(rel, arraycont, expr_stats, nexprs);
+
+	statext_store(stxentry->statOid, inh, ndistinct, dependencies, mcvlist,
+				  exprs, stats);
+}
+
+/*
+ * Import JSON-serialized stats to an Extended Statistics object.
+ */
+Datum
+pg_import_ext_stats(PG_FUNCTION_ARGS)
+{
+	Oid				stxid;
+	int32			stats_version_num;
+	Jsonb		   *jb;
+	JsonbContainer *cont;
+	Relation		rel;
+	HeapTuple		etup;
+	Relation		sd;
+	StatExtEntry   *stxentry;
+	VacAttrStats  **stats;
+
+	Form_pg_statistic_ext stxform;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("extended statistics oid cannot be NULL")));
+	stxid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("server_version_number cannot be NULL")));
+	stats_version_num = PG_GETARG_INT32(1);
+
+	if (stats_version_num < 100000)
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("invalid statistics version: %d is earlier than earliest supported version",
+				  stats_version_num)));
+
+	if (PG_ARGISNULL(2))
+		PG_RETURN_BOOL(false);
+
+	jb = PG_GETARG_JSONB_P(2);
+	if (!JB_ROOT_IS_OBJECT(jb))
+		ereport(ERROR,
+		  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+		   errmsg("extended_stats must be jsonb object at root")));
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	etup = SearchSysCacheCopy1(STATEXTOID, ObjectIdGetDatum(stxid));
+	if (!HeapTupleIsValid(etup))
+		elog(ERROR, "pg_statistic_ext entry for oid %u vanished during statistics import",
+			 stxid);
+
+	stxform = (Form_pg_statistic_ext) GETSTRUCT(etup);
+
+	rel = relation_open(stxform->stxrelid, ShareUpdateExclusiveLock);
+
+	stxentry = create_stat_ext_entry(etup);
+
+	stats = examine_ext_stat_types(stxentry, rel);
+
+	cont = key_lookup_object(&jb->root, "regular");
+	import_pg_statistic_ext_data(stxentry, rel, false, cont, stats);
+
+	if (rel->rd_rel->relhassubclass)
+	{
+		cont = key_lookup_object(&jb->root, "inherited");
+		import_pg_statistic_ext_data(stxentry, rel, true, cont, stats);
+	}
+
+	relation_close(rel, NoLock);
+	table_close(sd, RowExclusiveLock);
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index 03b9f04bb5..f1de17847a 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -29,6 +29,7 @@
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/bytea.h"
+#include "utils/float.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
@@ -679,7 +680,6 @@ statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats)
 			/* skip NULL values - we don't need to deduplicate those */
 			if (mcvlist->items[i].isnull[dim])
 				continue;
-
 			/* append the value at the end */
 			values[dim][counts[dim]] = mcvlist->items[i].values[dim];
 			counts[dim] += 1;
@@ -2177,3 +2177,218 @@ mcv_clause_selectivity_or(PlannerInfo *root, StatisticExtInfo *stat,
 
 	return s;
 }
+
+/*
+ * statext_mcv_import
+ *      like statext_mcv_build, but import from JSON.
+ *
+ * import format:
+ * [
+ *   {
+ *     "index": intstr,
+ *     "values": '{va1ue, ...}',
+ *     "nulls": '{t,f,...}',
+ *     "frequency": floatstr,
+ *     "base_frequency": floatstr
+ *   }
+ * ]
+ *
+ */
+MCVList *
+statext_mcv_import(JsonbContainer *cont, VacAttrStats **stats, int ndims)
+{
+	int			nitems;
+	int			i;
+	MCVList	   *mcvlist;
+	Oid		    ioparams[STATS_MAX_DIMENSIONS];
+	FmgrInfo	finfos[STATS_MAX_DIMENSIONS];
+
+	if (cont != NULL)
+		nitems = JsonContainerSize(cont);
+	else
+		nitems = 0;
+
+	mcvlist = (MCVList *) palloc0(offsetof(MCVList, items) +
+								  (sizeof(MCVItem) * nitems));
+
+	mcvlist->magic = STATS_MCV_MAGIC;
+	mcvlist->type = STATS_MCV_TYPE_BASIC;
+	mcvlist->nitems = nitems;
+	mcvlist->ndimensions = ndims;
+
+	/* We will need these input functions $nitems times. */
+	for (i = 0; i < ndims; i++)
+	{
+		Oid		typid = stats[i]->attrtypid;
+		Oid		infunc;
+
+		mcvlist->types[i] = typid;
+		getTypeInputInfo(typid, &infunc, &ioparams[i]);
+		fmgr_info(infunc, &finfos[i]);
+	}
+
+	for (i = 0; i < nitems; i++)
+	{
+		JsonbValue	   *j;
+		JsonbContainer *itemobj,
+					   *valuesarr,
+					   *nullsarr;
+		int				numvalues,
+						numnulls;
+		int				k;
+		MCVItem		   *item = &mcvlist->items[i];
+		char		   *s;
+
+		item->values = (Datum *) palloc0(sizeof(Datum) * ndims);
+		item->isnull = (bool *) palloc0(sizeof(bool) * ndims);
+
+		j = getIthJsonbValueFromContainer(cont, i);
+
+		if ((j == NULL)
+				|| (j->type != jbvBinary)
+				|| (!JsonContainerIsObject(j->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdmcv "
+					  "must be objects.")));
+
+		itemobj = j->val.binary.data;
+
+		s = key_lookup_cstring(itemobj, "frequency");
+		if (s != NULL)
+		{
+			item->frequency = float8in_internal(s, NULL, "double", s, NULL);
+			pfree(s);
+		}
+		else
+			item->frequency = 0.0;
+
+		s = key_lookup_cstring(itemobj, "base_frequency");
+		if (s != NULL)
+		{
+			item->base_frequency = float8in_internal(s, NULL, "double", s, NULL);
+			pfree(s);
+		}
+		else
+			item->base_frequency = 0.0;
+
+		/*
+		 * Import the nulls array first, because that tells us which elements
+		 * of the values array we can skip.
+		 */
+		nullsarr = key_lookup_array(itemobj, "nulls");
+
+		if (nullsarr == NULL)
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdmcv "
+					  "must contain an element called nulls which is an array.")));
+
+		numnulls = JsonContainerSize(nullsarr);
+
+		/* having more nulls than dimensions is concerning. */
+		if (numnulls > ndims)
+		{
+			ereport(WARNING,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("statistics import has %d mcv dimensions, "
+					  "but the expects %d. Skipping excess dimensions.",
+						numnulls, ndims)));
+			numnulls = ndims;
+		}
+
+		for (k = 0; k < numnulls; k++)
+		{
+			JsonbValue  *nj = getIthJsonbValueFromContainer(nullsarr, k);
+
+			if ((nj == NULL) || (nj->type != jbvBool))
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, elements of nulls "
+						  "must be boolens.")));
+
+			item->isnull[k] = nj->val.boolean;
+
+			pfree(nj);
+		}
+
+		/* Any remaining slots are marked null */
+		for (k = numnulls; k < ndims; k++)
+			item->isnull[k] = true;
+
+		valuesarr = key_lookup_array(itemobj, "values");
+
+		if (valuesarr == NULL)
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdmcv "
+					  "must contain an element called values which is an array.")));
+
+		numvalues = JsonContainerSize(valuesarr);
+
+		/* having more values than dimensions is concerning. */
+		if (numvalues > ndims)
+		{
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("statistics import has %d mcv dimensions, "
+					  "but the expects %d. Skipping excess dimensions.",
+						numvalues, ndims)));
+			numvalues = ndims;
+		}
+
+		for (k = 0; k < numvalues; k++)
+		{
+			JsonbValue *vj;
+			bool		import_error = true;
+
+			/* if the element was null flagged, don't bother */
+			if (item->isnull[k])
+			{
+				item->values[k] = (Datum) 0;
+				continue;
+			}
+
+			vj = getIthJsonbValueFromContainer(valuesarr, k);
+
+			if (vj != NULL)
+			{
+				if (vj->type == jbvString)
+				{
+					char   *str = JsonbStringValueToCString(vj);
+
+					item->values[k] = InputFunctionCall(&finfos[k],
+														str,
+														ioparams[k],
+														stats[k]->attrtypmod);
+
+					import_error = false;
+					pfree(str);
+				}
+				else if (vj->type == jbvNull)
+				{
+					item->values[k] = (Datum) 0;
+					item->isnull[k] = true; /* mark just in case */
+					import_error = false;
+				}
+				pfree(vj);
+			}
+
+			if (import_error)
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, elements of values "
+						  "must be strings or null.")));
+
+		}
+
+		/* Any remaining slots are marked null */
+		for (k = numvalues; k < ndims; k++)
+		{
+			item->values[k] = (Datum) 0;
+			item->isnull[k] = true;
+		}
+	}
+
+	return mcvlist;
+}
diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c
index 6d25c14644..e870ae02a4 100644
--- a/src/backend/statistics/mvdistinct.c
+++ b/src/backend/statistics/mvdistinct.c
@@ -31,6 +31,8 @@
 #include "lib/stringinfo.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -698,3 +700,102 @@ generate_combinations(CombinationGenerator *state)
 
 	pfree(current);
 }
+
+
+/*
+ * statext_ndistinct_import
+ *
+ * Like statext_ndistinct_build, but import the data
+ * from a JSON container.
+ *
+ * import format:
+ * [
+ *   {
+ *     "attnums": [ intstr, ... ],
+ *     "ndistinct": floatstr
+ *   }
+ * ]
+ *
+ */
+MVNDistinct *
+statext_ndistinct_import(JsonbContainer *cont)
+{
+	MVNDistinct	   *result;
+	int				nitems;
+	int				i;
+
+	if (cont == NULL)
+		return NULL;
+
+	nitems = JsonContainerSize(cont);
+
+	if (nitems == 0)
+		return NULL;
+
+	result = palloc(offsetof(MVNDistinct, items) +
+					(nitems * sizeof(MVNDistinctItem)));
+	result->magic = STATS_NDISTINCT_MAGIC;
+	result->type = STATS_NDISTINCT_TYPE_BASIC;
+	result->nitems = nitems;
+
+	for (i = 0; i < nitems; i++)
+	{
+		JsonbValue	   *j;
+		JsonbContainer *elemobj,
+					   *attnumarr;
+		int				a;
+		int				natts;
+		char		   *s;
+
+		MVNDistinctItem *item = &result->items[i];
+
+		j = getIthJsonbValueFromContainer(cont, i);
+
+		if ((j == NULL)
+				|| (j->type != jbvBinary)
+				|| (!JsonContainerIsObject(j->val.binary.data)))
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdndistinct "
+					  "must be objects.")));
+
+		elemobj = j->val.binary.data;
+
+		s = key_lookup_cstring(elemobj, "ndistinct");
+		item->ndistinct = float8in_internal(s, NULL, "double", s, NULL);
+		pfree(s);
+
+		attnumarr = key_lookup_array(elemobj, "attnums");
+
+		if (attnumarr == NULL)
+			ereport(ERROR,
+			  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			   errmsg("invalid statistics format, elements of stxdndistinct "
+					  "must contain an element called attnums which is an array.")));
+
+		natts = JsonContainerSize(attnumarr);
+		item->nattributes = natts;
+		item->attributes = palloc(sizeof(AttrNumber) * natts);
+
+		for (a = 0; a < natts; a++)
+		{
+			JsonbValue *aj;
+
+			aj = getIthJsonbValueFromContainer(attnumarr, a);
+
+			if ((aj == NULL) || (aj->type != jbvString))
+				ereport(ERROR,
+				  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				   errmsg("invalid statistics format, elements of attnums "
+						  "must be string representations of integers.")));
+			s = JsonbStringValueToCString(aj);
+			item->attributes[a] = pg_strtoint16(s);
+			pfree(s);
+			pfree(aj);
+		}
+
+		pfree(j);
+	}
+
+	return result;
+}
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
index 968ccfaaf2..e54f1c9162 100644
--- a/src/backend/statistics/statistics.c
+++ b/src/backend/statistics/statistics.c
@@ -364,7 +364,7 @@ void import_stanumbers(const VacAttrStats *stat, JsonbContainer *cont,
 		if (numnumbers > STATISTIC_NUM_SLOTS)
 			ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				errmsg("invalid format: number of stanumbers %d is greater than available slots %d",
+				errmsg("invalid format: number of stanumbers arrays (%d) is greater than available slots %d",
 						numnumbers, STATISTIC_NUM_SLOTS)));
 
 		fmgr_info(F_ARRAY_IN, &finfo);
@@ -474,8 +474,8 @@ void import_stavalues(const VacAttrStats *stat, JsonbContainer *cont,
 						typoid = typentry->typelem;
 				}
 				valvalues[k] = FunctionCall3(&finfo, CStringGetDatum(s),
-								 ObjectIdGetDatum(typoid),
-								 Int32GetDatum(typmod));
+											 ObjectIdGetDatum(typoid),
+											 Int32GetDatum(typmod));
 				valreplaces[k] = true;
 				pfree(s);
 				pfree(j);
@@ -664,7 +664,7 @@ examine_rel_attribute(Form_pg_attribute attr, Relation onerel, Node *index_expr)
 	if (!HeapTupleIsValid(typtuple))
 		elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
 	stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
-	stats->anl_context = CurrentMemoryContext;
+	stats->anl_context = NULL; /*DEBUG CurrentMemoryContext; */
 	stats->tupattnum = attr->attnum;
 
 	/*
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
index 2490472198..7c14f292e4 100644
--- a/src/test/regress/expected/stats_export_import.out
+++ b/src/test/regress/expected/stats_export_import.out
@@ -19,6 +19,7 @@ SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_import_complex_type,
 UNION ALL
 SELECT 4, 'four', NULL, NULL;
 CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
+CREATE STATISTICS evens_test ON name, ((comp).a % 2 = 0) FROM stats_import_test;
 ANALYZE stats_import_test;
 -- capture snapshot of source stats
 CREATE TABLE stats_export AS
@@ -57,6 +58,8 @@ WHERE oid = 'stats_import_test'::regclass;
 CREATE TABLE stats_import_clone ( LIKE stats_import_test );
 -- create an index just like is_odd
 CREATE INDEX is_odd2 ON stats_import_clone(((comp).a % 2 = 0));
+-- create a statistics object like evens_test
+CREATE STATISTICS evens_clone ON name, ((comp).a % 2 = 0) FROM stats_import_clone;
 -- copy table stats to clone table
 SELECT pg_import_rel_stats(c.oid, e.server_version_num,
                             e.n_tuples, e.n_pages, e.stats)
@@ -131,6 +134,23 @@ WHERE s.starelid = 'is_odd2'::regclass;
 -----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
 (0 rows)
 
+-- copy extended stats to clone table
+SELECT pg_import_ext_stats(
+        (
+            SELECT e.oid as ext_clone_oid
+            FROM pg_statistic_ext AS e
+            WHERE e.stxname = 'evens_clone'
+        ),
+        e.server_version_num, e.stats)
+FROM pg_catalog.pg_statistic_ext_export AS e
+WHERE e.schemaname = 'public'
+AND e.tablename = 'stats_import_test'
+AND e.ext_stats_name = 'evens_test';
+ pg_import_ext_stats 
+---------------------
+ t
+(1 row)
+
 DROP TABLE stats_export;
 DROP TABLE stats_import_clone;
 DROP TABLE stats_import_test;
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
index e97b9d1064..3bc8e3d3a3 100644
--- a/src/test/regress/sql/stats_export_import.sql
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -23,6 +23,8 @@ SELECT 4, 'four', NULL, NULL;
 
 CREATE INDEX is_odd ON stats_import_test(((comp).a % 2 = 1));
 
+CREATE STATISTICS evens_test ON name, ((comp).a % 2 = 0) FROM stats_import_test;
+
 ANALYZE stats_import_test;
 
 -- capture snapshot of source stats
@@ -53,6 +55,9 @@ CREATE TABLE stats_import_clone ( LIKE stats_import_test );
 -- create an index just like is_odd
 CREATE INDEX is_odd2 ON stats_import_clone(((comp).a % 2 = 0));
 
+-- create a statistics object like evens_test
+CREATE STATISTICS evens_clone ON name, ((comp).a % 2 = 0) FROM stats_import_clone;
+
 -- copy table stats to clone table
 SELECT pg_import_rel_stats(c.oid, e.server_version_num,
                             e.n_tuples, e.n_pages, e.stats)
@@ -113,6 +118,19 @@ SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
 FROM pg_statistic AS s
 WHERE s.starelid = 'is_odd2'::regclass;
 
+-- copy extended stats to clone table
+SELECT pg_import_ext_stats(
+        (
+            SELECT e.oid as ext_clone_oid
+            FROM pg_statistic_ext AS e
+            WHERE e.stxname = 'evens_clone'
+        ),
+        e.server_version_num, e.stats)
+FROM pg_catalog.pg_statistic_ext_export AS e
+WHERE e.schemaname = 'public'
+AND e.tablename = 'stats_import_test'
+AND e.ext_stats_name = 'evens_test';
+
 DROP TABLE stats_export;
 DROP TABLE stats_import_clone;
 DROP TABLE stats_import_test;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index ae3d1073e3..d9029fd29d 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28191,6 +28191,27 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
        </para></entry>
       </row>
      </tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_ext_stats</primary>
+        </indexterm>
+        <function>pg_import_ext_stats</function> ( <parameter>extended stats object</parameter> <type>oid</type>, <parameter>server_version_num</parameter> <type>integer</type>, <parameter>extended_stats</parameter> <type>jsonb</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_statistic_ext_data</structname> rows for the
+        <structfield>oid</structfield> matching
+        <parameter>extended statistics object</parameter> are transactionally
+        replaced with the values found in <parameter>extended_stats</parameter>.
+        The purpose of this function is to apply statistics values in an upgrade
+        situation that are "good enough" for system operation until they are
+        replaced by the next auto-analyze. This function could be used by
+        <program>pg_upgrade</program> and <program>pg_restore</program> to
+        convey the statistics from the old system version into the new one.
+       </para></entry>
+      </row>
+     </tbody>
     </tgroup>
    </table>
 
-- 
2.43.0

From aeffb52e6c744f624ea32b3ef587f5e9d0b5b85b Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Wed, 13 Dec 2023 05:21:00 -0500
Subject: [PATCH v3 9/9] Enable pg_export_stats, pg_import_stats to use
 extended statistics.

Both programs still use a single data stream. As a result, the columns
COPY-ed are a superset of both export tables, and on import the data
must first be loaded into a superset temporary table before being
separated into rel-specific and extended-specific tables.

While relation stats format is stable back to v10, the formats of
pg_statistic_ext and pg_statistic_ext_data change every version or two.
Extraction queries are provided back to v10, but currently only tested
back to v15. That's probably ok given that these programs primarily
serve as a reference and their functionality will most likely be moved
to pg_upgrade and pg_dump+pg_restore.
---
 src/bin/scripts/pg_export_stats.c | 448 +++++++++++++++++++++++++++++-
 src/bin/scripts/pg_import_stats.c | 289 +++++++++++++++----
 2 files changed, 672 insertions(+), 65 deletions(-)

diff --git a/src/bin/scripts/pg_export_stats.c b/src/bin/scripts/pg_export_stats.c
index abb3659e20..4aaafc729e 100644
--- a/src/bin/scripts/pg_export_stats.c
+++ b/src/bin/scripts/pg_export_stats.c
@@ -22,18 +22,20 @@
 static void help(const char *progname);
 
 /* view definition introduced in 17 */
-const char *export_query_v17 =
-	"SELECT schemaname, relname, server_version_num, n_tuples, "
-	"n_pages, stats FROM pg_statistic_export ";
+const char *export_rel_query_v17 =
+	"SELECT schemaname, relname, NULL::text AS ext_stats_name, "
+	"server_version_num, n_tuples, n_pages, stats "
+	"FROM pg_statistic_export ";
 
 /*
- * Versions 10-16 have the same stats layout, but lack the view definition,
- * so extracting the view definition ad using it as-is will work.
+ * Versions 10-16 have the same rel stats layout, but lack the view
+ * definition, so extracting the view definition ad using it as-is will work.
  */
-const char *export_query_v10 =
+const char *export_rel_query_v10 =
 	"SELECT "
 	"    n.nspname AS schemaname, "
 	"    r.relname AS relname, "
+	"    NULL::text AS ext_stats_name, "
 	"    current_setting('server_version_num')::integer AS server_version_num, "
 	"    r.reltuples::float4 AS n_tuples, "
 	"    r.relpages::integer AS n_pages, "
@@ -109,6 +111,412 @@ const char *export_query_v10 =
 	"WHERE relkind IN ('r', 'm', 'f', 'p', 'i') "
 	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
 
+/* view definition introduced in 17 */
+const char *export_ext_query_v17 =
+	"SELECT schemaname, relname, ext_stats_name, server_version_num, "
+	"NULL::float4 AS n_tuples, NULL::integer AS n_pages, stats "
+	"FROM pg_statistic_ext_export ";
+
+/* v15-v16 have the same extended stats layout, but lack the view definition */
+const char *export_ext_query_v15 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS tablename, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    NULL::float4 AS n_tuples, "
+	"    NULL::integer AS n_pages, "
+	"    jsonb_object_agg( "
+	"        CASE sd.stxdinherit "
+	"            WHEN true THEN 'inherited' "
+	"            ELSE 'regular' "
+	"        END, "
+	"        jsonb_build_object( "
+	"            'stxkinds', "
+	"            to_jsonb(e.stxkind), "
+	"            'stxdndistinct', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array(nd.attnums, ', '::text), "
+	"                            'ndistinct', "
+	"                            nd.ndistinct "
+	"                            ) "
+	"                        ORDER BY nd.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                    WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                WHERE sd.stxdndistinct IS NOT NULL "
+	"            ), "
+	"            'stxdndependencies', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array( "
+	"                                replace(dep.attrs, ' => ', ', '), ', ' "
+	"                            ), "
+	"                            'degree', "
+	"                            dep.degree "
+	"                        ) "
+	"                        ORDER BY dep.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxddependencies::text::json) "
+	"                    WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                WHERE sd.stxddependencies IS NOT NULL "
+	"            ), "
+	"            'stxdmcv', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'index', "
+	"                            mcvl.index::text, "
+	"                            'frequency', "
+	"                            mcvl.frequency::text, "
+	"                            'base_frequency', "
+	"                            mcvl.base_frequency::text, "
+	"                            'values', "
+	"                            mcvl.values, "
+	"                            'nulls', "
+	"                            mcvl.nulls "
+	"                        ) "
+	"                    ) "
+	"                FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                WHERE sd.stxdmcv IS NOT NULL "
+	"            ), "
+	"            'stxdexprs', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'stanullfrac', "
+	"                            s.stanullfrac::text, "
+	"                            'stawidth', "
+	"                            s.stawidth::text, "
+	"                            'stadistinct', "
+	"                            s.stadistinct::text, "
+	"                            'stakinds', "
+	"                            ( "
+	"                                SELECT "
+	"                                    jsonb_agg( "
+	"                                        CASE kind.kind "
+	"                                            WHEN 0 THEN 'TRIVIAL' "
+	"                                            WHEN 1 THEN 'MCV' "
+	"                                            WHEN 2 THEN 'HISTOGRAM' "
+	"                                            WHEN 3 THEN 'CORRELATION' "
+	"                                            WHEN 4 THEN 'MCELEM' "
+	"                                            WHEN 5 THEN 'DECHIST' "
+	"                                            WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                            WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                            ELSE NULL "
+	"                                        END "
+	"                                        ORDER BY kind.ord "
+	"                                    ) "
+	"                                FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                                  s.stakind3, s.stakind4, "
+	"                                                  s.stakind5]) "
+	"                                    WITH ORDINALITY kind(kind, ord) "
+	"                            ), "
+	"                            'stanumbers', "
+	"                            jsonb_build_array( "
+	"                                s.stanumbers1::text, "
+	"                                s.stanumbers2::text, "
+	"                                s.stanumbers3::text, "
+	"                                s.stanumbers4::text, "
+	"                                s.stanumbers5::text "
+	"                            ), "
+	"                            'stavalues', "
+	"                            jsonb_build_array( "
+	"                                s.stavalues1::text, "
+	"                                s.stavalues2::text, "
+	"                                s.stavalues3::text, "
+	"                                s.stavalues4::text, "
+	"                                s.stavalues5::text) "
+	"                            ) "
+	"                            ORDER BY s.ordinality "
+	"                        ) "
+	"                FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s "
+	"                WHERE sd.stxdexpr IS NOT NULL "
+	"            ) "
+	"        ) "
+	"    ) AS stats "
+	"FROM pg_class r "
+	"JOIN pg_namespace n ON n.oid = r.relnamespace "
+	"JOIN pg_statistic_ext e ON e.stxrelid = r.oid "
+	"JOIN pg_statistic_ext_data sd ON sd.stxoid = e.oid "
+	"GROUP BY schemaname, tablename, ext_stats_name, server_version_num ";
+
+/* v14 is like v15, but lacks stxdinherit on pg_statistic_ext_data */
+const char *export_ext_query_v14 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS tablename, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    NULL::float4 AS n_tuples, "
+	"    NULL::integer AS n_pages, "
+	"    jsonb_object_agg( "
+	"        'regular', "
+	"        jsonb_build_object( "
+	"            'stxkinds', "
+	"            to_jsonb(e.stxkind), "
+	"            'stxdndistinct', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array(nd.attnums, ', '::text), "
+	"                            'ndistinct', "
+	"                            nd.ndistinct "
+	"                            ) "
+	"                        ORDER BY nd.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                    WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                WHERE sd.stxdndistinct IS NOT NULL "
+	"            ), "
+	"            'stxdndependencies', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array( "
+	"                                replace(dep.attrs, ' => ', ', '), ', ' "
+	"                            ), "
+	"                            'degree', "
+	"                            dep.degree "
+	"                        ) "
+	"                        ORDER BY dep.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxddependencies::text::json) "
+	"                    WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                WHERE sd.stxddependencies IS NOT NULL "
+	"            ), "
+	"            'stxdmcv', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'index', "
+	"                            mcvl.index::text, "
+	"                            'frequency', "
+	"                            mcvl.frequency::text, "
+	"                            'base_frequency', "
+	"                            mcvl.base_frequency::text, "
+	"                            'values', "
+	"                            mcvl.values, "
+	"                            'nulls', "
+	"                            mcvl.nulls "
+	"                        ) "
+	"                    ) "
+	"                FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                WHERE sd.stxdmcv IS NOT NULL "
+	"            ), "
+	"            'stxdexprs', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'stanullfrac', "
+	"                            s.stanullfrac::text, "
+	"                            'stawidth', "
+	"                            s.stawidth::text, "
+	"                            'stadistinct', "
+	"                            s.stadistinct::text, "
+	"                            'stakinds', "
+	"                            ( "
+	"                                SELECT "
+	"                                    jsonb_agg( "
+	"                                        CASE kind.kind "
+	"                                            WHEN 0 THEN 'TRIVIAL' "
+	"                                            WHEN 1 THEN 'MCV' "
+	"                                            WHEN 2 THEN 'HISTOGRAM' "
+	"                                            WHEN 3 THEN 'CORRELATION' "
+	"                                            WHEN 4 THEN 'MCELEM' "
+	"                                            WHEN 5 THEN 'DECHIST' "
+	"                                            WHEN 6 THEN 'RANGE_LENGTH_HISTOGRAM' "
+	"                                            WHEN 7 THEN 'BOUNDS_HISTOGRAM' "
+	"                                            ELSE NULL "
+	"                                        END "
+	"                                        ORDER BY kind.ord "
+	"                                    ) "
+	"                                FROM unnest(ARRAY[s.stakind1, s.stakind2, "
+	"                                                  s.stakind3, s.stakind4, "
+	"                                                  s.stakind5]) "
+	"                                    WITH ORDINALITY kind(kind, ord) "
+	"                            ), "
+	"                            'stanumbers', "
+	"                            jsonb_build_array( "
+	"                                s.stanumbers1::text, "
+	"                                s.stanumbers2::text, "
+	"                                s.stanumbers3::text, "
+	"                                s.stanumbers4::text, "
+	"                                s.stanumbers5::text "
+	"                            ), "
+	"                            'stavalues', "
+	"                            jsonb_build_array( "
+	"                                s.stavalues1::text, "
+	"                                s.stavalues2::text, "
+	"                                s.stavalues3::text, "
+	"                                s.stavalues4::text, "
+	"                                s.stavalues5::text) "
+	"                            ) "
+	"                            ORDER BY s.ordinality "
+	"                        ) "
+	"                FROM unnest(sd.stxdexpr) WITH ORDINALITY AS s "
+	"                WHERE sd.stxdexpr IS NOT NULL "
+	"            ) "
+	"        ) "
+	"    ) AS stats "
+	"FROM pg_class r "
+	"JOIN pg_namespace n ON n.oid = r.relnamespace "
+	"JOIN pg_statistic_ext e ON e.stxrelid = r.oid "
+	"JOIN pg_statistic_ext_data sd ON sd.stxoid = e.oid "
+	"GROUP BY schemaname, tablename, ext_stats_name, server_version_num ";
+
+/* v12-v13 are like v14, but lack stxdexpr on pg_statistic_ext_data */
+const char *export_ext_query_v12 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS tablename, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    NULL::float4 AS n_tuples, "
+	"    NULL::integer AS n_pages, "
+	"    jsonb_object_agg( "
+	"        'regular', "
+	"        jsonb_build_object( "
+	"            'stxkinds', "
+	"            to_jsonb(e.stxkind), "
+	"            'stxdndistinct', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array(nd.attnums, ', '::text), "
+	"                            'ndistinct', "
+	"                            nd.ndistinct "
+	"                            ) "
+	"                        ORDER BY nd.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxdndistinct::text::json) "
+	"                    WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                WHERE sd.stxdndistinct IS NOT NULL "
+	"            ), "
+	"            'stxdndependencies', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array( "
+	"                                replace(dep.attrs, ' => ', ', '), ', ' "
+	"                            ), "
+	"                            'degree', "
+	"                            dep.degree "
+	"                        ) "
+	"                        ORDER BY dep.ord "
+	"                    ) "
+	"                FROM json_each_text(sd.stxddependencies::text::json) "
+	"                    WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                WHERE sd.stxddependencies IS NOT NULL "
+	"            ), "
+	"            'stxdmcv', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'index', "
+	"                            mcvl.index::text, "
+	"                            'frequency', "
+	"                            mcvl.frequency::text, "
+	"                            'base_frequency', "
+	"                            mcvl.base_frequency::text, "
+	"                            'values', "
+	"                            mcvl.values, "
+	"                            'nulls', "
+	"                            mcvl.nulls "
+	"                        ) "
+	"                    ) "
+	"                FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                WHERE sd.stxdmcv IS NOT NULL "
+	"            ) "
+	"        ) "
+	"    ) AS stats "
+	"FROM pg_class r "
+	"JOIN pg_namespace n ON n.oid = r.relnamespace "
+	"JOIN pg_statistic_ext e ON e.stxrelid = r.oid "
+	"JOIN pg_statistic_ext_data sd ON sd.stxoid = e.oid "
+	"GROUP BY schemaname, tablename, ext_stats_name, server_version_num ";
+
+/*
+ * v10-v11 are like v12, but:
+ *     - MCV is gone
+ *     - remaining stats are stored on pg_statistic_ext
+ *     - pg_statistic_ext_data is gone
+ */
+
+const char *export_ext_query_v10 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS tablename, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    NULL::float4 AS n_tuples, "
+	"    NULL::integer AS n_pages, "
+	"    jsonb_object_agg( "
+	"        'regular', "
+	"        jsonb_build_object( "
+	"            'stxkinds', "
+	"            to_jsonb(e.stxkind), "
+	"            'stxdndistinct', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array(nd.attnums, ', '::text), "
+	"                            'ndistinct', "
+	"                            nd.ndistinct "
+	"                            ) "
+	"                        ORDER BY nd.ord "
+	"                    ) "
+	"                FROM json_each_text(e.stxndistinct::text::json) "
+	"                    WITH ORDINALITY AS nd(attnums, ndistinct, ord) "
+	"                WHERE e.stxndistinct IS NOT NULL "
+	"            ), "
+	"            'stxdndependencies', "
+	"            ( "
+	"                SELECT "
+	"                    jsonb_agg( "
+	"                        jsonb_build_object( "
+	"                            'attnums', "
+	"                            string_to_array( "
+	"                                replace(dep.attrs, ' => ', ', '), ', ' "
+	"                            ), "
+	"                            'degree', "
+	"                            dep.degree "
+	"                        ) "
+	"                        ORDER BY dep.ord "
+	"                    ) "
+	"                FROM json_each_text(e.stxdependencies::text::json) "
+	"                    WITH ORDINALITY AS dep(attrs, degree, ord) "
+	"                WHERE e.stxdependencies IS NOT NULL "
+	"            ) "
+	"        ) "
+	"    ) AS stats "
+	"FROM pg_class r "
+	"JOIN pg_namespace n ON n.oid = r.relnamespace "
+	"JOIN pg_statistic_ext e ON e.stxrelid = r.oid "
+	"GROUP BY schemaname, tablename, ext_stats_name, server_version_num ";
+
 int
 main(int argc, char *argv[])
 {
@@ -138,6 +546,7 @@ main(int argc, char *argv[])
 	PQExpBufferData sql;
 
 	PGconn	   *conn;
+	int			server_version_num;
 
 	FILE	   *copystream = stdout;
 
@@ -227,14 +636,31 @@ main(int argc, char *argv[])
 
 	conn = connectDatabase(&cparams, progname, echo, false, true);
 
+	server_version_num = PQserverVersion(conn);
+
 	initPQExpBuffer(&sql);
 
 	appendPQExpBufferStr(&sql, "COPY (");
 
-	if (PQserverVersion(conn) >= 170000)
-		appendPQExpBufferStr(&sql, export_query_v17);
-	else if (PQserverVersion(conn) >= 100000)
-		appendPQExpBufferStr(&sql, export_query_v10);
+	if (server_version_num >= 170000)
+		appendPQExpBufferStr(&sql, export_rel_query_v17);
+	else if (server_version_num >= 100000)
+		appendPQExpBufferStr(&sql, export_rel_query_v10);
+	else
+		pg_fatal("exporting statistics from databases prior to version 10 not supported");
+
+	appendPQExpBufferStr(&sql, " UNION ALL ");
+
+	if (server_version_num >= 170000)
+		appendPQExpBufferStr(&sql, export_ext_query_v17);
+	else if (server_version_num >= 150000)
+		appendPQExpBufferStr(&sql, export_ext_query_v15);
+	else if (server_version_num >= 140000)
+		appendPQExpBufferStr(&sql, export_ext_query_v14);
+	else if (server_version_num >= 120000)
+		appendPQExpBufferStr(&sql, export_ext_query_v12);
+	else if (server_version_num >= 100000)
+		appendPQExpBufferStr(&sql, export_ext_query_v10);
 	else
 		pg_fatal("exporting statistics from databases prior to version 10 not supported");
 
@@ -244,7 +670,7 @@ main(int argc, char *argv[])
 	result_status = PQresultStatus(result);
 
 	if (result_status != PGRES_COPY_OUT)
-		pg_fatal("malformed copy command");
+		pg_fatal("malformed copy command: %s", PQerrorMessage(conn));
 
 	for (;;)
 	{
diff --git a/src/bin/scripts/pg_import_stats.c b/src/bin/scripts/pg_import_stats.c
index 122afc0971..a8b6f9c701 100644
--- a/src/bin/scripts/pg_import_stats.c
+++ b/src/bin/scripts/pg_import_stats.c
@@ -57,6 +57,7 @@ main(int argc, char *argv[])
 
 	int		i;
 	int		numtables;
+	int		numextstats;
 
 	pg_logging_init(argv[0]);
 	progname = get_progname(argv[0]);
@@ -141,21 +142,69 @@ main(int argc, char *argv[])
 
 	/* iterate over records */
 
-
+	/*
+	 * Create a table that can received the COPY-ed file which is a mix
+	 * of relation statistics and extended statistics.
+	 */
 	result = PQexec(conn,
 		"CREATE TEMPORARY TABLE import_stats ( "
+		"schemaname text, "
+		"relname text, "
+		"ext_stats_name text, "
+		"server_version_num integer, "
+		"n_tuples float4, "
+		"n_pages integer, "
+		"stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	/*
+	 * Create a table just for the relation statistics
+	 */
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_rel_stats ( "
+		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
+		"schemaname text, "
+		"relname text, "
+		"server_version_num integer, "
+		"n_tuples float4, "
+		"n_pages integer, "
+		"stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
+
+
+	PQclear(result);
+
+	/*
+	 * Create a table just for extended statistics
+	 */
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_ext_stats ( "
 		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
-		"schemaname text, relname text, server_version_num integer, "
-		"n_tuples float4, n_pages integer, stats jsonb )");
+		"schemaname text, "
+		"relname text, "
+		"ext_stats_name text, "
+		"server_version_num integer, "
+		"n_tuples float4, "
+		"n_pages integer, "
+		"stats jsonb )");
 
 	if (PQresultStatus(result) != PGRES_COMMAND_OK)
-		pg_fatal("could not create temporary file: %s", PQerrorMessage(conn));
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
 
 	PQclear(result);
 
+	/*
+	 * Copy input data into combined table.
+	 */
 	result = PQexec(conn,
-		"COPY import_stats(schemaname, relname, server_version_num, n_tuples, "
-		"n_pages, stats) FROM STDIN");
+		"COPY import_stats(schemaname, relname, ext_stats_name, "
+		"server_version_num, n_tuples, n_pages, stats) FROM STDIN");
 
 	if (PQresultStatus(result) != PGRES_COPY_IN)
 		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
@@ -185,30 +234,52 @@ main(int argc, char *argv[])
 	if (PQresultStatus(result) != PGRES_COMMAND_OK)
 		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
 
+	PQclear(result);
+
+	/*
+	 * Insert rel stats into their own table with numbering.
+	 */
+	result = PQexec(conn,
+		"INSERT INTO import_rel_stats(schemaname, relname, "
+		"server_version_num, n_tuples, n_pages, stats) "
+		"SELECT schemaname, relname, server_version_num, "
+		"n_tuples, n_pages, stats FROM import_stats "
+		"WHERE ext_stats_name IS NULL ");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("relation stats insert error: %s", PQerrorMessage(conn));
+
 	numtables = atol(PQcmdTuples(result));
 
 	PQclear(result);
 
-	result = PQprepare(conn, "import",
-		"SELECT pg_import_rel_stats(c.oid, s.server_version_num, "
-		"             s.n_tuples, s.n_pages, s.stats) as import_result "
-		"FROM import_stats AS s "
-		"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
-		"JOIN pg_class AS c ON c.relnamespace = n.oid "
-		"                   AND c.relname = s.relname "
-		"WHERE s.id = $1::bigint ",
-		1, NULL);
+	/*
+	 * Insert extended stats into their own table with numbering.
+	 */
+	result = PQexec(conn,
+		"INSERT INTO import_ext_stats(schemaname, relname, "
+		"ext_stats_name, server_version_num, stats) "
+		"SELECT schemaname, relname, ext_stats_name, "
+		"server_version_num, stats FROM import_stats "
+		"WHERE ext_stats_name IS NOT NULL ");
 
 	if (PQresultStatus(result) != PGRES_COMMAND_OK)
-		pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+		pg_fatal("relation stats insert error: %s", PQerrorMessage(conn));
+
+	numextstats = atol(PQcmdTuples(result));
 
 	PQclear(result);
 
-	if (!quiet)
+	if (numtables > 0)
 	{
-		result = PQprepare(conn, "echo",
-			"SELECT s.schemaname, s.relname "
-			"FROM import_stats AS s "
+
+		result = PQprepare(conn, "import_rel",
+			"SELECT pg_import_rel_stats(c.oid, s.server_version_num, "
+			"             s.n_tuples, s.n_pages, s.stats) as import_result "
+			"FROM import_rel_stats AS s "
+			"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+			"JOIN pg_class AS c ON c.relnamespace = n.oid "
+			"                   AND c.relname = s.relname "
 			"WHERE s.id = $1::bigint ",
 			1, NULL);
 
@@ -216,62 +287,172 @@ main(int argc, char *argv[])
 			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
 
 		PQclear(result);
-	}
 
-	for (i = 1; i <= numtables; i++)
-	{
-		char	istr[32];
-		char   *schema = NULL;
-		char   *table = NULL;
+		if (!quiet)
+		{
+			result = PQprepare(conn, "echo_rel",
+				"SELECT s.schemaname, s.relname "
+				"FROM import_rel_stats AS s "
+				"WHERE s.id = $1::bigint ",
+				1, NULL);
 
-		const char *const values[] = {istr};
+			if (PQresultStatus(result) != PGRES_COMMAND_OK)
+				pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
 
-		snprintf(istr, 32, "%d", i);
+			PQclear(result);
+		}
 
-		if (!quiet)
+		for (i = 1; i <= numtables; i++)
 		{
-			result = PQexecPrepared(conn, "echo", 1, values, NULL, NULL, 0);
-			schema = pg_strdup(PQgetvalue(result, 0, 0));
-			table = pg_strdup(PQgetvalue(result, 0, 1));
+			char	istr[32];
+			char   *schema = NULL;
+			char   *table = NULL;
+
+			const char *const values[] = {istr};
+
+			snprintf(istr, 32, "%d", i);
+
+			if (!quiet)
+			{
+				result = PQexecPrepared(conn, "echo_rel", 1, values, NULL, NULL, 0);
+				schema = pg_strdup(PQgetvalue(result, 0, 0));
+				table = pg_strdup(PQgetvalue(result, 0, 1));
+			}
+
+			PQclear(result);
+
+			result = PQexecPrepared(conn, "import_rel", 1, values, NULL, NULL, 0);
+
+			if (quiet)
+			{
+				PQclear(result);
+				continue;
+			}
+
+			if (PQresultStatus(result) == PGRES_TUPLES_OK)
+			{
+				int 	rows = PQntuples(result);
+
+				if (rows == 1)
+				{
+					char   *retval = PQgetvalue(result, 0, 0);
+					if (*retval == 't')
+						printf("%s.%s: imported\n", schema, table);
+					else
+						printf("%s.%s: failed\n", schema, table);
+				}
+				else if (rows == 0)
+					printf("%s.%s: not found\n", schema, table);
+				else
+					pg_fatal("import function must return 0 or 1 rows");
+			}
+			else
+				printf("%s.%s: error: %s\n", schema, table, PQerrorMessage(conn));
+
+			if (schema != NULL)
+				pfree(schema);
+
+			if (table != NULL)
+				pfree(table);
+
+			PQclear(result);
 		}
+	}
 
-		PQclear(result);
+	if (numextstats > 0)
+	{
+
+	result = PQprepare(conn, "import_ext",
+		"SELECT pg_import_ext_stats(e.oid, s.server_version_num, "
+		"             s.stats) as import_result "
+		"FROM import_ext_stats AS s "
+		"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+		"JOIN pg_class AS c ON c.relnamespace = n.oid "
+		"                   AND c.relname = s.relname "
+		"JOIN pg_statistic_ext AS e ON e.stxrelid = c.oid "
+		"                   AND e.stxname = s.ext_stats_name "
+		"WHERE s.id = $1::bigint ",
+		1, NULL);
 
-		result = PQexecPrepared(conn, "import", 1, values, NULL, NULL, 0);
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
 
-		if (quiet)
+		PQclear(result);
+
+		if (!quiet)
 		{
+			result = PQprepare(conn, "echo_ext",
+				"SELECT s.schemaname, s.relname, s.ext_stats_name "
+				"FROM import_ext_stats AS s "
+				"WHERE s.id = $1::bigint ",
+				1, NULL);
+
+			if (PQresultStatus(result) != PGRES_COMMAND_OK)
+				pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
 			PQclear(result);
-			continue;
 		}
 
-		if (PQresultStatus(result) == PGRES_TUPLES_OK)
+		for (i = 1; i <= numextstats; i++)
 		{
-			int 	rows = PQntuples(result);
+			char	istr[32];
+			char   *schema = NULL;
+			char   *table = NULL;
+			char   *stat = NULL;
+
+			const char *const values[] = {istr};
+
+			snprintf(istr, 32, "%d", i);
 
-			if (rows == 1)
+			if (!quiet)
 			{
-				char   *retval = PQgetvalue(result, 0, 0);
-				if (*retval == 't')
-					printf("%s.%s: imported\n", schema, table);
+				result = PQexecPrepared(conn, "echo_ext", 1, values, NULL, NULL, 0);
+				schema = pg_strdup(PQgetvalue(result, 0, 0));
+				table = pg_strdup(PQgetvalue(result, 0, 1));
+				stat = pg_strdup(PQgetvalue(result, 0, 2));
+			}
+
+			PQclear(result);
+
+			result = PQexecPrepared(conn, "import_ext", 1, values, NULL, NULL, 0);
+
+			if (quiet)
+			{
+				PQclear(result);
+				continue;
+			}
+
+			if (PQresultStatus(result) == PGRES_TUPLES_OK)
+			{
+				int 	rows = PQntuples(result);
+
+				if (rows == 1)
+				{
+					char   *retval = PQgetvalue(result, 0, 0);
+					if (*retval == 't')
+						printf("%s on %s.%s: imported\n", stat, schema, table);
+					else
+						printf("%s on %s.%s: failed\n", stat, schema, table);
+				}
+				else if (rows == 0)
+					printf("%s on %s.%s: not found\n", stat, schema, table);
 				else
-					printf("%s.%s: failed\n", schema, table);
+					pg_fatal("import function must return 0 or 1 rows");
 			}
-			else if (rows == 0)
-				printf("%s.%s: not found\n", schema, table);
 			else
-				pg_fatal("import function must return 0 or 1 rows");
-		}
-		else
-			printf("%s.%s: error: %s\n", schema, table, PQerrorMessage(conn));
+				printf("%s on %s.%s: error: %s\n", stat, schema, table, PQerrorMessage(conn));
 
-		if (schema != NULL)
-			pfree(schema);
+			if (schema != NULL)
+				pfree(schema);
 
-		if (table != NULL)
-			pfree(table);
+			if (table != NULL)
+				pfree(table);
 
-		PQclear(result);
+			if (stat != NULL)
+				pfree(stat);
+
+			PQclear(result);
+		}
 	}
 
 	exit(0);
-- 
2.43.0

From 6bdc7076d20ff4cd71b851ea34f8ffa69fe03f67 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Fri, 2 Feb 2024 00:16:04 -0500
Subject: [PATCH v4 1/3] Create pg_import_rel_stats.

The function pg_import_rel_stats imports pg_class rowcount,
pagecount, and pg_statistic data for a given relation.

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a jsonb parameter which contains the generated
statistics for one relaton, the format of which varies by the version
of the server that exported it. The function takes that version
int account when processing the input json into pg_statistic rows.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

While the statistics are applied transactionally, the changes to
pg_class (reltuples and relpages) are not. This decision was made
to avoid bloat of pg_class and is in line with the behavior of VACUUM.

Currently the function supports two boolean flags for checking the
validity of the imported data. The flag validate initiates a battery
of validation tests to ensure that all sub-objects (types, operators,
collatons, attributes, statistics) have no duplicate values. The flag
require_match_oids verifies the oids resolved in the new statistics rows
match the oids specified in the json. Setting this flag makes sense
during a binary upgrade, but not a restore.

This function also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |    6 +-
 src/include/statistics/statistics.h           |   20 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1390 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  530 +++++++
 src/test/regress/parallel_schedule            |    2 +-
 src/test/regress/sql/stats_export_import.sql  |  499 ++++++
 doc/src/sgml/func.sgml                        |   56 +
 9 files changed, 2504 insertions(+), 3 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 29af4ce65d..ec8ce7c3c0 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -8825,7 +8825,11 @@
 { oid => '3813', descr => 'generate XML text node',
   proname => 'xmltext', proisstrict => 't', prorettype => 'xml',
   proargtypes => 'text', prosrc => 'xmltext' },
-
+{ oid => '3814',
+  descr => 'statistics: import to relation',
+  proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_rel_stats' },
 { oid => '2923', descr => 'map table contents to XML',
   proname => 'table_to_xml', procost => '100', provolatile => 's',
   proparallel => 'r', prorettype => 'xml',
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..11a213e21a 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,24 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_import_rel_stats(PG_FUNCTION_ARGS);
+
+extern VacAttrStats *examine_rel_attribute(Relation onerel, int attnum,
+										   Node *index_expr);
+
+extern HeapTuple *import_pg_statistics(Relation rel, Relation sd,
+									   int server_version_num,
+									   const Datum *datums, const bool *nulls,
+									   bool require_match_oids, int *ntuples);
+
+extern void validate_no_duplicates(Datum document, bool document_null,
+								   const char *sql, const char *docname,
+								   const char *colname);
+
+extern void validate_exported_types(Datum types, bool types_null);
+extern void validate_exported_collations(Datum collations, bool collations_null);
+extern void validate_exported_operators(Datum operators, bool operators_null);
+extern void validate_exported_attributes(Datum attributes, bool attributes_null);
+extern void validate_exported_statistics(Datum statistics, bool statistics_null);
+
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..6cba780691
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1390 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics.c
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "executor/spi.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/rel.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Struct to capture only the infomration we need from
+ * examine_attribute.
+ */
+typedef struct {
+	Oid		typid;
+	int32	typmod;
+	Oid 	eqopr;
+	Oid 	ltopr;
+	Oid		basetypid;
+	Oid 	baseeqopr;
+	Oid 	baseltopr;
+} AttrInfo;
+
+
+/*
+ * Generate AttrInfo entries for each attribute in the relation.
+ * This data is a small subset of what VacAttrStats collects,
+ * and we leverage VacAttrStats to stay compatible with what
+ * do_analyze() does.
+ */
+static AttrInfo *
+get_attrinfo(Relation rel)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	bool		has_index_exprs = false;
+	ListCell   *indexpr_item = NULL;
+	AttrInfo   *res = palloc0(natts * sizeof(AttrInfo));
+	int			i;
+
+	/*
+	 * If this relation is an index and that index has expressions in
+	 * it, then we will need to keep the list of remaining expressions
+	 * aligned with the attributes as we iterate over them, whether or
+	 * not those attributes have statistics to import.
+	*/
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+				|| (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+			&& (rel->rd_indexprs != NIL))
+	{
+		has_index_exprs = true;
+		indexpr_item = list_head(rel->rd_indexprs);
+	}
+
+	for (i = 0; i < natts; i++)
+	{
+		Node *index_expr = NULL;
+		VacAttrStats *stats;
+
+		/*
+		 * If this this attribute is an expression, pop an expression off
+		 * of the list.
+		 */
+		if (has_index_exprs && (rel->rd_index->indkey.values[i] == 0))
+		{
+			if (indexpr_item == NULL)   /* shouldn't happen */
+				elog(ERROR, "too few entries in indexprs list");
+
+			index_expr = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+		}
+
+		stats = examine_rel_attribute(rel, i+1, index_expr);
+
+		res[i].typid = stats->attrtypid;
+		res[i].typmod = stats->attrtypmod;
+		get_sort_group_operators(res[i].typid,
+								 false, false, false,
+								 &res[i].ltopr, &res[i].eqopr, NULL,
+								 NULL);
+
+		get_sort_group_operators(res[i].typid,
+								 false, false, false,
+								 &res[i].ltopr, &res[i].eqopr, NULL,
+								 NULL);
+
+		res[i].basetypid = get_base_element_type(stats->attrtypid);
+		if (res[i].basetypid == InvalidOid)
+		{
+			/* type is its own base type */
+			res[i].basetypid = res[i].typid;
+			res[i].baseltopr = res[i].ltopr;
+			res[i].baseeqopr = res[i].eqopr;
+		}
+		else
+			get_sort_group_operators(res[i].basetypid,
+									 false, false, false,
+									 &res[i].baseltopr, &res[i].baseeqopr,
+									 NULL, NULL);
+
+	}
+	return res;
+}
+
+/*
+ * examine_rel_attribute -- pre-analysis of a single column
+ *
+ * Determine whether the column is analyzable; if so, create and initialize
+ * a VacAttrStats struct for it.  If not, return NULL.
+ *
+ * If index_expr isn't NULL, then we're trying to import an expression index,
+ * and index_expr is the expression tree representing the column's data.
+ */
+VacAttrStats *
+examine_rel_attribute(Relation onerel, int attnum, Node *index_expr)
+{
+	Form_pg_attribute attr = TupleDescAttr(onerel->rd_att, attnum - 1);
+	HeapTuple		typtuple;
+	VacAttrStats   *stats;
+	int				i;
+	bool			ok;
+
+	/* Never analyze dropped columns */
+	if (attr->attisdropped)
+		return NULL;
+
+	/*
+	 * Create the VacAttrStats struct.
+	 */
+	stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
+	stats->attstattarget = 1; /* Any nonzero value */
+
+	/*
+	 * When analyzing an expression index, believe the expression tree's type
+	 * not the column datatype --- the latter might be the opckeytype storage
+	 * type of the opclass, which is not interesting for our purposes.  (Note:
+	 * if we did anything with non-expression index columns, we'd need to
+	 * figure out where to get the correct type info from, but for now that's
+	 * not a problem.)	It's not clear whether anyone will care about the
+	 * typmod, but we store that too just in case.
+	 */
+	if (index_expr)
+	{
+		stats->attrtypid = exprType(index_expr);
+		stats->attrtypmod = exprTypmod(index_expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(onerel->rd_indcollation[attnum - 1]))
+			stats->attrcollid = onerel->rd_indcollation[attnum - 1];
+		else
+			stats->attrcollid = exprCollation(index_expr);
+	}
+	else
+	{
+		stats->attrtypid = attr->atttypid;
+		stats->attrtypmod = attr->atttypmod;
+		stats->attrcollid = attr->attcollation;
+	}
+
+	typtuple = SearchSysCacheCopy1(TYPEOID,
+								   ObjectIdGetDatum(stats->attrtypid));
+	if (!HeapTupleIsValid(typtuple))
+		elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
+	stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
+	stats->anl_context = NULL;
+	stats->tupattnum = attnum;
+
+	/*
+	 * The fields describing the stats->stavalues[n] element types default to
+	 * the type of the data being analyzed, but the type-specific typanalyze
+	 * function can change them if it wants to store something else.
+	 */
+	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
+	{
+		stats->statypid[i] = stats->attrtypid;
+		stats->statyplen[i] = stats->attrtype->typlen;
+		stats->statypbyval[i] = stats->attrtype->typbyval;
+		stats->statypalign[i] = stats->attrtype->typalign;
+	}
+
+	/*
+	 * Call the type-specific typanalyze function.  If none is specified, use
+	 * std_typanalyze().
+	 */
+	if (OidIsValid(stats->attrtype->typanalyze))
+		ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
+										   PointerGetDatum(stats)));
+	else
+		ok = std_typanalyze(stats);
+
+	if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
+	{
+		heap_freetuple(typtuple);
+		pfree(stats);
+		return NULL;
+	}
+
+	return stats;
+}
+
+/*
+ * Delete all pg_statistic entries for a relation + inheritance type
+ */
+static void
+remove_pg_statistics(Relation rel, Relation sd, bool inh)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	int			attnum;
+
+	for (attnum = 1; attnum <= natts; attnum++)
+	{
+		HeapTuple tup = SearchSysCache3(STATRELATTINH,
+							ObjectIdGetDatum(RelationGetRelid(rel)),
+							Int16GetDatum(attnum),
+							BoolGetDatum(inh));
+
+		if (HeapTupleIsValid(tup))
+		{
+			CatalogTupleDelete(sd, &tup->t_self);
+
+			ReleaseSysCache(tup);
+		}
+	}
+}
+
+#define NULLARG(x) ((x) ? 'n' : ' ')
+
+/*
+ * A common pattern of duplicate detection.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_no_duplicates(Datum document, bool document_null,
+					   const char *sql, const char *docname,
+					   const char *colname)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { document };
+	char	argnulls[1] = { NULLARG(document_null) };
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		char *s = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s",
+						docname, colname, (s) ? s : "NULL")));
+	}
+}
+
+/*
+ * Ensure that the "types" document is valid.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_types(Datum types, bool types_null)
+{
+	const char *sql =
+		"SELECT et.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS et(oid oid, typname text, nspname text) "
+		"GROUP BY et.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(types, types_null, sql, "types", "oid");
+}
+
+/*
+ * Ensure that the "collations" document is valid.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_collations(Datum collations, bool collations_null)
+{
+	const char* sql =
+		"SELECT ec.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ec(oid oid, collname text, nspname text) "
+		"GROUP BY ec.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(collations, collations_null, sql, "collations", "oid");
+}
+
+/*
+ * Ensure that the "operators" document is valid.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_operators(Datum operators, bool operators_null)
+{
+	const char* sql =
+		"SELECT eo.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS eo(oid oid, oprname text, nspname text) "
+		"GROUP BY eo.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(operators, operators_null, sql, "operators", "oid");
+}
+
+/*
+ * Ensure that the "attributes" document is valid.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_attributes(Datum attributes, bool attributes_null)
+{
+	const char* sql =
+		"SELECT ea.attnum "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ea(attnum int2, attname text, atttypid oid, "
+		"           attcollation oid) "
+		"GROUP BY ea.attnum "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(attributes, attributes_null, sql, "attributes", "attnum");
+}
+
+/*
+ * Ensure that the "statistics" document is valid.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_statistics(Datum statistics, bool statistics_null)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { statistics };
+	char	argnulls[1] = { NULLARG(statistics_null) };
+
+	const char *sql =
+		"SELECT s.staattnum, s.stainherit "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"GROUP BY s.staattnum, s.stainherit "
+		"HAVING COUNT(*) > 1 ";
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (tuptable->numvals > 0)
+	{
+		char *s1 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		char *s2 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 2);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s, %s = %s",
+						"statistics", "staattnum", (s1) ? s1 : "NULL",
+						"stainherit", (s2) ? s2 : "NULL")));
+	}
+}
+
+
+/*
+ * Transactionally import statistics for a given relation
+ * into pg_statistic.
+ *
+ * The jsonb datums are in the same order:
+ *     types, collations, operators, attributes, statistics
+ *
+ * The statistics import query does not vary by server version.
+ * However, the stacollN columns will always be NULL for versions prior
+ * to v12.
+ *
+ * The query as currently written is clearly overboard, and for now serves
+ * to show what is possible in terms of comparing the exported statistics
+ * to the existing local schema. Once we have determined what types of
+ * checks are worthwhile, we can trim out unnecessary joins and columns.
+ *
+ * Analytic columns columns like dup_count serve to check the consistency
+ * and correctness of the exported data.
+ *
+ * The return value is an array of HeapTuples.
+ * The parameter ntuples is set to the number of HeapTuples returned.
+ */
+
+HeapTuple *
+import_pg_statistics(Relation rel, Relation sd, int server_version_num,
+					 const Datum *datums, const bool *nulls,
+					 bool require_match_oids, int *ntuples)
+{
+
+#define PGS_NARGS 6
+
+	Oid			argtypes[PGS_NARGS] = {
+					JSONBOID, JSONBOID, JSONBOID, JSONBOID, JSONBOID, OIDOID };
+	Datum		args[PGS_NARGS] = {
+					datums[0], datums[1], datums[2], datums[3], datums[4],
+					ObjectIdGetDatum(RelationGetRelid(rel)) };
+	char		argnulls[PGS_NARGS] = {
+					NULLARG(nulls[0]), NULLARG(nulls[1]), NULLARG(nulls[2]),
+					NULLARG(nulls[3]), NULLARG(nulls[4]) };
+
+	/*
+	 * This query is currently in kitchen-sink mode, and it can be trimmed down
+	 * to eliminate any columns not needed for output or validation once
+	 * all requirements are settled.
+	 */
+	const char *sql =
+		"WITH exported_types AS ( "
+		"    SELECT et.* "
+		"    FROM jsonb_to_recordset($1) "
+		"        AS et(oid oid, typname text, nspname text) "
+		"), "
+		"exported_collations AS ( "
+		"    SELECT ec.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS ec(oid oid, collname text, nspname text) "
+		"), "
+		"exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($3) "
+		"        AS eo(oid oid, oprname text, nspname text) "
+		"), "
+		"exported_attributes AS ( "
+		"    SELECT ea.* "
+		"    FROM jsonb_to_recordset($4) "
+		"        AS ea(attnum int2, attname text, atttypid oid, "
+		"              attcollation oid) "
+		"), "
+		"exported_statistics AS ( "
+		"    SELECT s.* "
+		"    FROM jsonb_to_recordset($5) "
+		"        AS s(staattnum integer, "
+		"             stainherit boolean, "
+		"             stanullfrac float4, "
+		"             stawidth integer, "
+		"             stadistinct float4, "
+		"             stakind1 int2, "
+		"             stakind2 int2, "
+		"             stakind3 int2, "
+		"             stakind4 int2, "
+		"             stakind5 int2, "
+		"             staop1 oid, "
+		"             staop2 oid, "
+		"             staop3 oid, "
+		"             staop4 oid, "
+		"             staop5 oid, "
+		"             stacoll1 oid, "
+		"             stacoll2 oid, "
+		"             stacoll3 oid, "
+		"             stacoll4 oid, "
+		"             stacoll5 oid, "
+		"             stanumbers1 float4[], "
+		"             stanumbers2 float4[], "
+		"             stanumbers3 float4[], "
+		"             stanumbers4 float4[], "
+		"             stanumbers5 float4[], "
+		"             stavalues1 text, "
+		"             stavalues2 text, "
+		"             stavalues3 text, "
+		"             stavalues4 text, "
+		"             stavalues5 text) "
+		") "
+		"SELECT pga.attnum, pga.attname, pga.atttypid, pga.atttypmod, "
+		"       pga.attcollation, pgat.typname, pgac.collname, "
+		"       ea.attnum AS exp_attnum, ea.atttypid AS exp_atttypid, "
+		"       ea.attcollation AS exp_attcollation, "
+		"       et.typname AS exp_typname, et.nspname AS exp_typschema, "
+		"       ec.collname AS exp_collname, ec.nspname AS exp_collschema, "
+		"       es.stainherit, es.stanullfrac, es.stawidth, es.stadistinct, "
+		"       es.stakind1, es.stakind2, es.stakind3, es.stakind4, "
+		"       es.stakind5, "
+		"       es.staop1 AS exp_staop1, es.staop2 AS exp_staop2, "
+		"       es.staop3 AS exp_staop3, es.staop4 AS exp_staop4, "
+		"       es.staop5 AS exp_staop5, "
+		"       es.stacoll1 AS exp_staop1, es.stacoll2 AS exp_staop2, "
+		"       es.stacoll3 AS exp_staop3, es.stacoll4 AS exp_staop4, "
+		"       es.stacoll5 AS exp_staop5, "
+		"       es.stanumbers1, es.stanumbers2, es.stanumbers3, "
+		"       es.stanumbers4, es.stanumbers5, "
+		"       es.stavalues1, es.stavalues2, es.stavalues3, es.stavalues4, "
+		"       es.stavalues5, "
+		"       eo1.nspname AS exp_oprschema1, "
+		"       eo2.nspname AS exp_oprschema2, "
+		"       eo3.nspname AS exp_oprschema3, "
+		"       eo4.nspname AS exp_oprschema4, "
+		"       eo5.nspname AS exp_oprschema5, "
+		"       eo1.oprname AS exp_oprname1, "
+		"       eo2.oprname AS exp_oprname2, "
+		"       eo3.oprname AS exp_oprname3, "
+		"       eo4.oprname AS exp_oprname4, "
+		"       eo5.oprname AS exp_oprname5, "
+		"       coalesce(io1.oid, 0) AS staop1, "
+		"       coalesce(io2.oid, 0) AS staop2, "
+		"       coalesce(io3.oid, 0) AS staop3, "
+		"       coalesce(io4.oid, 0) AS staop4, "
+		"       coalesce(io5.oid, 0) AS staop5, "
+		"       ec1.nspname AS exp_collschema1, "
+		"       ec2.nspname AS exp_collschema2, "
+		"       ec3.nspname AS exp_collschema3, "
+		"       ec4.nspname AS exp_collschema4, "
+		"       ec5.nspname AS exp_collschema5, "
+		"       ec1.collname AS exp_collname1, "
+		"       ec2.collname AS exp_collname2, "
+		"       ec3.collname AS exp_collname3, "
+		"       ec4.collname AS exp_collname4, "
+		"       ec5.collname AS exp_collname5, "
+		"       coalesce(ic1.oid, 0) AS stacoll1, "
+		"       coalesce(ic2.oid, 0) AS stacoll2, "
+		"       coalesce(ic3.oid, 0) AS stacoll3, "
+		"       coalesce(ic4.oid, 0) AS stacoll4, "
+		"       coalesce(ic5.oid, 0) AS stacoll5, "
+		"       (pga.attname IS DISTINCT FROM ea.attname) AS attname_miss, "
+		"       (ea.attnum IS DISTINCT FROM es.staattnum) AS staattnum_miss, "
+		"       COUNT(*) OVER (PARTITION BY pga.attnum, "
+		"                                   es.stainherit) AS dup_count "
+		"FROM pg_attribute AS pga "
+		"JOIN pg_type AS pgat ON pgat.oid = pga.atttypid "
+		"LEFT JOIN pg_collation AS pgac ON pgac.oid = pga.attcollation "
+		"LEFT JOIN exported_attributes AS ea ON ea.attname = pga.attname "
+		"LEFT JOIN exported_statistics AS es ON es.staattnum = ea.attnum "
+		"LEFT JOIN exported_types AS et ON et.oid = ea.atttypid "
+		"LEFT JOIN exported_collations AS ec ON ec.oid = ea.attcollation "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = es.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = es.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = es.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = es.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = es.staop5 "
+		"LEFT JOIN exported_collations AS ec1 ON ec1.oid = es.stacoll1 "
+		"LEFT JOIN exported_collations AS ec2 ON ec2.oid = es.stacoll2 "
+		"LEFT JOIN exported_collations AS ec3 ON ec3.oid = es.stacoll3 "
+		"LEFT JOIN exported_collations AS ec4 ON ec4.oid = es.stacoll4 "
+		"LEFT JOIN exported_collations AS ec5 ON ec5.oid = es.stacoll5 "
+		"LEFT JOIN pg_namespace AS ion1 ON ion1.nspname = eo1.nspname "
+		"LEFT JOIN pg_namespace AS ion2 ON ion2.nspname = eo2.nspname "
+		"LEFT JOIN pg_namespace AS ion3 ON ion3.nspname = eo3.nspname "
+		"LEFT JOIN pg_namespace AS ion4 ON ion4.nspname = eo4.nspname "
+		"LEFT JOIN pg_namespace AS ion5 ON ion5.nspname = eo5.nspname "
+		"LEFT JOIN pg_namespace AS icn1 ON icn1.nspname = ec1.nspname "
+		"LEFT JOIN pg_namespace AS icn2 ON icn2.nspname = ec2.nspname "
+		"LEFT JOIN pg_namespace AS icn3 ON icn3.nspname = ec3.nspname "
+		"LEFT JOIN pg_namespace AS icn4 ON icn4.nspname = ec4.nspname "
+		"LEFT JOIN pg_namespace AS icn5 ON icn5.nspname = ec5.nspname "
+		"LEFT JOIN pg_operator AS io1 ON io1.oprnamespace = ion1.oid "
+		"    AND io1.oprname = eo1.oprname "
+		"    AND io1.oprleft = pga.atttypid "
+		"    AND io1.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io2 ON io2.oprnamespace = ion2.oid "
+		"    AND io2.oprname = eo2.oprname "
+		"    AND io2.oprleft = pga.atttypid "
+		"    AND io2.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io3 ON io3.oprnamespace = ion3.oid "
+		"    AND io3.oprname = eo3.oprname "
+		"    AND io3.oprleft = pga.atttypid "
+		"    AND io3.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io4 ON io4.oprnamespace = ion4.oid "
+		"    AND io4.oprname = eo4.oprname "
+		"    AND io4.oprleft = pga.atttypid "
+		"    AND io4.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io5 ON io5.oprnamespace = ion5.oid "
+		"    AND io5.oprname = eo5.oprname "
+		"    AND io5.oprleft = pga.atttypid "
+		"    AND io5.oprright = pga.atttypid "
+		"LEFT JOIN pg_collation as ic1 "
+		"   ON ic1.collnamespace = icn1.oid AND ic1.collname = ec1.collname "
+		"LEFT JOIN pg_collation as ic2 "
+		"   ON ic2.collnamespace = icn2.oid AND ic2.collname = ec2.collname "
+		"LEFT JOIN pg_collation as ic3 "
+		"   ON ic3.collnamespace = icn3.oid AND ic3.collname = ec3.collname "
+		"LEFT JOIN pg_collation as ic4 "
+		"   ON ic4.collnamespace = icn4.oid AND ic4.collname = ec4.collname "
+		"LEFT JOIN pg_collation as ic5 "
+		"   ON ic5.collnamespace = icn5.oid AND ic5.collname = ec5.collname "
+		"WHERE pga.attrelid = $6 "
+		"AND pga.attnum > 0 "
+		"ORDER BY pga.attnum, coalesce(es.stainherit, false)";
+
+	/*
+	 * Columns with names containing _EXP_ are values that come from exported
+	 * json data and therefore should not be directly imported into
+	 * pg_statistic. Those values were joined to current catalog values to
+	 * derive the proper value to import, and the column is exposed mostly
+	 * for validation purposes.
+	 */
+	enum
+	{
+		PGS_ATTNUM = 0,
+		PGS_ATTNAME,
+		PGS_ATTTYPID,
+		PGS_ATTTYPMOD,
+		PGS_ATTCOLLATION,
+		PGS_TYPNAME,
+		PGS_COLLNAME,
+		PGS_EXP_ATTNUM,
+		PGS_EXP_ATTTYPID,
+		PGS_EXP_ATTCOLLATION,
+		PGS_EXP_TYPNAME,
+		PGS_EXP_TYPSCHEMA,
+		PGS_EXP_COLLNAME,
+		PGS_EXP_COLLSCHEMA,
+		PGS_STAINHERIT,
+		PGS_STANULLFRAC,
+		PGS_STAWIDTH,
+		PGS_STADISTINCT,
+		PGS_STAKIND1,
+		PGS_STAKIND2,
+		PGS_STAKIND3,
+		PGS_STAKIND4,
+		PGS_STAKIND5,
+		PGS_EXP_STAOP1,
+		PGS_EXP_STAOP2,
+		PGS_EXP_STAOP3,
+		PGS_EXP_STAOP4,
+		PGS_EXP_STAOP5,
+		PGS_EXP_STACOLL1,
+		PGS_EXP_STACOLL2,
+		PGS_EXP_STACOLL3,
+		PGS_EXP_STACOLL4,
+		PGS_EXP_STACOLL5,
+		PGS_STANUMBERS1,
+		PGS_STANUMBERS2,
+		PGS_STANUMBERS3,
+		PGS_STANUMBERS4,
+		PGS_STANUMBERS5,
+		PGS_STAVALUES1,
+		PGS_STAVALUES2,
+		PGS_STAVALUES3,
+		PGS_STAVALUES4,
+		PGS_STAVALUES5,
+		PGS_EXP_OPRSCHEMA1,
+		PGS_EXP_OPRSCHEMA2,
+		PGS_EXP_OPRSCHEMA3,
+		PGS_EXP_OPRSCHEMA4,
+		PGS_EXP_OPRSCHEMA5,
+		PGS_EXP_OPRNAME1,
+		PGS_EXP_OPRNAME2,
+		PGS_EXP_OPRNAME3,
+		PGS_EXP_OPRNAME4,
+		PGS_EXP_OPRNAME5,
+		PGS_STAOP1,
+		PGS_STAOP2,
+		PGS_STAOP3,
+		PGS_STAOP4,
+		PGS_STAOP5,
+		PGS_EXP_COLLSCHEMA1,
+		PGS_EXP_COLLSCHEMA2,
+		PGS_EXP_COLLSCHEMA3,
+		PGS_EXP_COLLSCHEMA4,
+		PGS_EXP_COLLSCHEMA5,
+		PGS_EXP_COLLNAME1,
+		PGS_EXP_COLLNAME2,
+		PGS_EXP_COLLNAME3,
+		PGS_EXP_COLLNAME4,
+		PGS_EXP_COLLNAME5,
+		PGS_STACOLL1,
+		PGS_STACOLL2,
+		PGS_STACOLL3,
+		PGS_STACOLL4,
+		PGS_STACOLL5,
+		PGS_ATTNAME_MISS,
+		PGS_STAATTNUM_MISS,
+		PGS_DUP_COUNT,
+		NUM_PGS_COLS
+	};
+
+	AttrInfo	*relattrinfo = get_attrinfo(rel);
+	AttrInfo	*attrinfo;
+
+	int		ret;
+	int		i;
+	int		tupctr = 0;
+
+	SPITupleTable  *tuptable;
+	HeapTuple	   *rettuples;
+
+	ret = SPI_execute_with_args(sql, PGS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	rettuples = palloc0(sizeof(HeapTuple) * tuptable->numvals);
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum		pgs_datums[NUM_PGS_COLS];
+		bool		pgs_nulls[NUM_PGS_COLS];
+		bool		skip = false;
+
+		Datum		values[Natts_pg_statistic] = { 0 };
+		bool		nulls[Natts_pg_statistic] = { false };
+
+		int			dup_count;
+		AttrNumber	attnum;
+		char	   *attname;
+		bool		stainherit;
+		char	   *inhstr;
+		AttrNumber	exported_attnum;
+		FmgrInfo	finfo;
+		int			k;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, pgs_datums,
+						  pgs_nulls);
+
+		/*
+		 * Check all the columns that cannot plausibly be null regardless of
+		 * json data quality
+		 */
+		Assert(!pgs_nulls[PGS_ATTNUM]);
+		Assert(!pgs_nulls[PGS_ATTNAME]);
+		Assert(!pgs_nulls[PGS_ATTTYPID]);
+		Assert(!pgs_nulls[PGS_ATTTYPMOD]);
+		Assert(!pgs_nulls[PGS_ATTCOLLATION]);
+		Assert(!pgs_nulls[PGS_TYPNAME]);
+		Assert(!pgs_nulls[PGS_DUP_COUNT]);
+		Assert(!pgs_nulls[PGS_ATTNAME_MISS]);
+		Assert(!pgs_nulls[PGS_STAATTNUM_MISS]);
+
+		attnum = DatumGetInt16(pgs_datums[PGS_ATTNUM]);
+		attname = NameStr(*(DatumGetName(pgs_datums[PGS_ATTNAME])));
+		attrinfo = &relattrinfo[attnum - 1];
+
+		fmgr_info(F_ARRAY_IN, &finfo);
+
+		if (pgs_nulls[PGS_STAINHERIT])
+		{
+			stainherit = false;
+			inhstr = "NULL";
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAINHERIT]))
+		{
+			stainherit = true;
+			inhstr = "true";
+		}
+		else
+		{
+			stainherit = false;
+			inhstr = "false";
+		}
+
+		/*
+		 * Any duplicates would be a cache collision and a sign that the
+		 * import json is broken.
+		 */
+		dup_count = DatumGetInt32(pgs_datums[PGS_DUP_COUNT]);
+		if (dup_count != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Attribute duplicate count %d on attnum %d attname %s stainherit %s",
+							dup_count, attnum, attname, stainherit ? "t" : "f")));
+		else if (DatumGetBool(pgs_datums[PGS_ATTNAME_MISS]))
+		{
+			/* Do not generate a tuple */
+			skip = true;
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported attribute with name \"%s\" found.", attname)));
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAATTNUM_MISS]))
+		{
+			/* Do not generate a tuple */
+			skip = true;
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported statistic found for exported attribute \"%s\" found.",
+								attname)));
+		}
+
+		/* if we are going to skip this row, clean up first */
+		if (skip)
+		{
+			pfree(attname);
+			continue;
+		}
+
+		exported_attnum = DatumGetInt16(pgs_datums[PGS_EXP_ATTNUM]);
+
+		if (require_match_oids)
+		{
+			Oid	export_typoid = DatumGetObjectId(pgs_datums[PGS_EXP_ATTTYPID]);
+			Oid	catalog_typoid = DatumGetObjectId(pgs_datums[PGS_ATTTYPID]);
+
+			if (export_typoid != catalog_typoid)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d expects typoid %u but typoid %u imported",
+								attnum, catalog_typoid, export_typoid)));
+		}
+
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
+		values[Anum_pg_statistic_staattnum - 1] = pgs_datums[PGS_ATTNUM];
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(stainherit);
+
+		/*
+		 * Any nulls here will fail the when it is written to pg_statistic
+		 * but that error message is as good as any we could create.
+		 */
+		if (pgs_nulls[PGS_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stanullfrac")));
+
+		if (pgs_nulls[PGS_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stawidth")));
+
+		if (pgs_nulls[PGS_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = pgs_datums[PGS_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = pgs_datums[PGS_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = pgs_datums[PGS_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind;
+			Oid		op;
+
+			/*
+			 * stakindN
+			 *
+			 * We can't match order of stakinds from VacAttrStats because which
+			 * entries appear varies by the data in the table.
+			 *
+			 * The stakindN values assigned during ANALYZE will vary by the
+			 * amount and quality of the data sampled. As such, there is no
+			 * fixed set of kinds to match against for any one slot.
+			 *
+			 * Any NULL stakindN values will cause the row to fail.
+			 *
+			 */
+			if (pgs_nulls[PGS_STAKIND1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stakind", k+1)));
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = pgs_datums[PGS_STAKIND1 + k];
+			kind = DatumGetInt16(pgs_datums[PGS_STAKIND1 + k]);
+
+			/*
+			 * staopN
+			 *
+			 * We cannot resolve the exported operator back to a local Oid because
+			 * that cannot be looked up directly in the catalog, so we have to
+			 * instead look at the exported operator name, choose the op from
+			 * the typecache, and then if we're requiring matching oids we can
+			 * compare that to the exported oid.
+			 *
+			 */
+			/* Possibly validate operator must be OidIsValid when stakindN <> 0 */
+			if (pgs_nulls[PGS_EXP_OPRNAME1 + k])
+				op = InvalidOid;
+			else
+			{
+				char   *exp_oprname;
+
+				exp_oprname = TextDatumGetCString(pgs_datums[PGS_EXP_OPRNAME1 + k]);
+				if (strcmp(exp_oprname, "=") == 0)
+				{
+					/*
+					 * MCELEM stat arrays are of the same type as the
+					 * array base element type and are eqopr
+					 */
+					if ((kind == STATISTIC_KIND_MCELEM) ||
+						(kind == STATISTIC_KIND_DECHIST))
+						op = attrinfo->baseeqopr;
+					else
+						op = attrinfo->eqopr;
+				}
+				else if (strcmp(exp_oprname, "<") == 0)
+					op = attrinfo->ltopr;
+				else
+					op = InvalidOid;
+				pfree(exp_oprname);
+			}
+
+			if (require_match_oids)
+			{
+				if (pgs_nulls[PGS_EXP_STAOP1 + k])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d staop%d kind %d expects Oid %u but NULL imported",
+									attnum, k+1, kind,  op)));
+				else
+				{
+					Oid	export_op = DatumGetObjectId(pgs_datums[PGS_EXP_STAOP1 + k]);
+					if (export_op != op)
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("Attribute %d staop%d kind %d expects Oid %u but Oid %u imported",
+										attnum, k+1, kind,  op, export_op)));
+				}
+			}
+			values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(op);
+
+			/* Any NULL stacollN will fail the row */
+			if (pgs_nulls[PGS_STACOLL1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stacoll", k+1)));
+			values[Anum_pg_statistic_stacoll1 - 1 + k] = pgs_datums[PGS_STACOLL1 + k];
+
+			if (require_match_oids)
+			{
+				Oid	export_coll = DatumGetObjectId(pgs_datums[PGS_EXP_STACOLL1 + k]);
+				Oid	import_coll = DatumGetObjectId(pgs_datums[PGS_STACOLL1 + k]);
+
+				if (export_coll != import_coll)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d stacoll%d expects Oid %u but Oid %u imported",
+									attnum, k+1, export_coll, import_coll)));
+			}
+
+			/* stanumbersN - the import query did the required type coercion. */
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_datums[PGS_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_nulls[PGS_STANUMBERS1 + k];
+
+			/* stavaluesN */
+			if (pgs_nulls[PGS_STAVALUES1 + k])
+			{
+				nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			}
+			else
+			{
+				char    *s = TextDatumGetCString(pgs_datums[PGS_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(attrinfo->basetypid),
+								  Int32GetDatum(attrinfo->typmod));
+
+				pfree(s);
+			}
+		}
+
+		/* Add valid tuple to the list */
+		rettuples[tupctr++] = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+	}
+
+	pfree(relattrinfo);
+	*ntuples = tupctr;
+	return rettuples;
+}
+
+/*
+ * Import statistics for a given relation.
+ *
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   "reltuples": number, -- pg_class.reltuples
+ *   "relpages": number, -- pg_class.relpages
+ *   "types": [
+ *         -- export of all pg_type referenced in this json doc
+ *         {
+ *            "oid": number, -- pg_type.oid
+ *            "typname": string, -- pg_type.typname
+ *            "nspname": string -- schema name for the pg_type
+ *         }
+ *      ],
+ *   "collations": [
+ *         -- export all pg_collation reference in this json doc
+ *         {
+ *            "oid": number, -- pg_collation.oid
+ *            "collname": string, -- pg_collation.collname
+ *            "nspname": string -- schema name for the pg_collation
+ *         }
+ *      ],
+ *   "operators": [
+ *         -- export all pg_operator reference in this json doc
+ *         {
+ *            "oid": number, -- pg_operator.oid
+ *            "collname": string, -- pg_oprname
+ *            "nspname": string -- schema name for the pg_operator
+ *         }
+ *      ],
+ *   "attributes": [
+ *         -- export all pg_attribute for the exported relation
+ *         {
+ *            "attnum": number, -- pg_attribute.attnum
+ *            "attname": string, -- pg_attribute.attname
+ *            "atttypid": number, -- pg_attribute.atttypid
+ *            "attcollation": number -- pg_attribute.attcollation
+ *         }
+ *      ],
+ *   "statistics": [
+ *         -- export all pg_statistic for the exported relation
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *      ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+
+ */
+Datum
+pg_import_rel_stats(PG_FUNCTION_ARGS)
+{
+	Oid		relid;
+	bool	validate;
+	bool	require_match_oids;
+
+	const char *sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    relname text, "
+		"    nspname text, "
+		"    reltuples float4,"
+		"    relpages int4, "
+		"    types jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    attributes jsonb, "
+		"    statistics jsonb) ";
+
+	enum
+	{
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_RELTUPLES,
+		BQ_RELPAGES,
+		BQ_TYPES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_ATTRIBUTES,
+		BQ_STATISTICS,
+		NUM_BQ_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid			argtypes[BQ_NARGS] = { JSONBOID };
+	Datum		args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Datum	datums[NUM_BQ_COLS];
+	bool	nulls[NUM_BQ_COLS];
+
+	int32	server_version_num;
+	int32	current_version_num;
+
+	Relation	rel;
+	Relation	sd;
+	HeapTuple  *sdtuples;
+	int			nsdtuples;
+	int			i;
+
+	CatalogIndexState	indstate = NULL;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("relation cannot be NULL")));
+	relid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(sql, BQ_NARGS, argtypes, args, NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("statistic export JSON should return only one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, datums, nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	if (require_match_oids)
+	{
+		char   *curr_relname = SPI_getrelname(rel);
+		char   *curr_nspname = SPI_getnspname(rel);
+		char   *import_relname;
+		char   *import_nspname;
+
+		if (nulls[BQ_RELNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name must match relation name, but is null")));
+
+		if (nulls[BQ_NSPNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name must match schema name, but is null")));
+
+		import_relname = TextDatumGetCString(datums[BQ_RELNAME]);
+		import_nspname = TextDatumGetCString(datums[BQ_NSPNAME]);
+
+		if (strcmp(import_relname, curr_relname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name (%s) must match relation name (%s), but does not",
+							import_relname, curr_relname)));
+
+		if (strcmp(import_nspname, curr_nspname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name (%s) must match schema name (%s), but does not",
+							import_nspname, curr_nspname)));
+
+		pfree(curr_relname);
+		pfree(curr_nspname);
+		pfree(import_relname);
+		pfree(import_nspname);
+	}
+
+	/*
+	 * validations
+	 *
+	 * Potential future validations:
+	 *
+	 *  * all attributes.atttypid values are represented in "types"
+	 *  * all attributes.attcollation values are represented in "types"
+	 *  * attributes.attname is of acceptable length
+	 *  * all non-invalid statistics.opN values are represented in "operators"
+	 *  * all non-invalid statistics.collN values are represented in "collations"
+	 *  * statistincs.kindN values in 0-7
+	 *  * statistics.stanullfrac in range
+	 *  * statistics.stawidth in range
+	 *  * statistics.ndistinct in rage
+	 *
+	 */
+	if (validate)
+	{
+		validate_exported_types(datums[BQ_TYPES], nulls[BQ_TYPES]);
+		validate_exported_collations(datums[BQ_COLLATIONS], nulls[BQ_COLLATIONS]);
+		validate_exported_operators(datums[BQ_OPERATORS], nulls[BQ_OPERATORS]);
+		validate_exported_attributes(datums[BQ_ATTRIBUTES], nulls[BQ_ATTRIBUTES]);
+		validate_exported_statistics(datums[BQ_STATISTICS], nulls[BQ_STATISTICS]);
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	sdtuples = import_pg_statistics(rel, sd, server_version_num,
+									&datums[BQ_TYPES], &nulls[BQ_TYPES],
+									require_match_oids, &nsdtuples);
+
+	/* Open index information when we know we need it */
+	indstate = CatalogOpenIndexes(sd);
+
+	/* Delete existing pg_statistic rows for relation to avoid collisions */
+	remove_pg_statistics(rel, sd, false);
+	if (RELKIND_HAS_PARTITIONS(rel->rd_rel->relkind))
+		remove_pg_statistics(rel, sd, true);
+
+	for (i = 0; i < nsdtuples; i++)
+	{
+		CatalogTupleInsertWithInfo(sd, sdtuples[i], indstate);
+		heap_freetuple(sdtuples[i]);
+	}
+
+	CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+	pfree(sdtuples);
+
+	/*
+	 * Update pg_class tuple directly (non-transactionally, same as
+	 * is done in do_analyze().
+	 *
+	 * Only modify pg_class row if changes are to be made
+	 */
+	if (!nulls[BQ_RELTUPLES] || !nulls[BQ_RELPAGES])
+	{
+		Relation		pg_class_rel;
+		HeapTuple		ctup;
+		Form_pg_class	pgcform;
+
+		/*
+		 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+		 * other stat-setting operation can run on it concurrently.
+		 */
+		pg_class_rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+		/* leave if relation could not be opened or locked */
+		if (!pg_class_rel)
+			PG_RETURN_BOOL(false);
+
+		ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+		if (!HeapTupleIsValid(ctup))
+			elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+				 relid);
+
+		pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+		/* leave un-set values alone */
+		if (!nulls[BQ_RELTUPLES])
+			pgcform->reltuples = DatumGetFloat4(datums[BQ_RELTUPLES]);
+
+		if(!nulls[BQ_RELPAGES])
+			pgcform->relpages = DatumGetInt32(datums[BQ_RELPAGES]);
+
+		heap_inplace_update(pg_class_rel, ctup);
+		table_close(pg_class_rel, ShareUpdateExclusiveLock);
+	}
+
+	relation_close(rel, NoLock);
+
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..5ab51c5aa0
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,530 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+ count 
+-------
+     5
+(1 row)
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+ table_stats_json 
+------------------
+(0 rows)
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+ index_stats_json 
+------------------
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+ count 
+-------
+     0
+(1 row)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         0
+ test    |        -1
+(2 rows)
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "types" has duplicate rows with oid = 2
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "collations" has duplicate rows with oid = 1
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "operators" has duplicate rows with oid = 3
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "attributes" has duplicate rows with attnum = 4
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "statistics" has duplicate rows with staattnum = 1, stainherit = f
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..9a80eebeec
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,499 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 6788ba8ef4..d16983dff3 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28689,6 +28689,62 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_rel_stats</primary>
+        </indexterm>
+        <function>pg_import_rel_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>relation_stats</parameter> <type>jsonb</type>, <parameter>validate</parameter> <type>bool</type>, <parameter>require_match_oids</parameter> <type>bool</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_class</structname> row with the
+        <structfield>oid</structfield> matching <parameter>relation</parameter>
+        to set the <structfield>reltuples</structfield> and
+        <structfield>relpages</structfield> fields. This is done nontransactionally.
+        The <structname>pg_statistic</structname> rows for the
+        <structfield>statrelid</structfield> matching <parameter>relation</parameter>
+        are replaced with the values found in <parameter>relation_stats</parameter>,
+        and this is done transactionally. The purpose of this function is to apply
+        statistics values in an upgrade situation that are "good enough" for system
+        operation until they are replaced by the next auto-analyze. This function
+        could be used by <command>pg_upgrade</command> and
+        <command>pg_restore</command> to convey the statistics from the old system
+        version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>relation_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para>
+       <para>
+        If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
+        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
+        not match the values specified in <parameter>relation_json</parameter>, as would be expected
+        in a binary upgrade. These assumptions would not be true when restoring from a dump.
+       </para></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.43.0

From a9de415586cb1dd73c06c173100be9aa6ea47695 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Fri, 2 Feb 2024 02:59:50 -0500
Subject: [PATCH v4 2/3] This is the extended statistics equivalent of
 pg_import_rel_stats().

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The exported values stored in the parameter extended_stats are
compared against the existing structure in pg_statistic_ext and are
transformed into pg_statistic_ext_data rows, transactionally replacing
any pre-existing rows for that object.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

This function also allows for tweaking of table statistics in-place,
allowing the user to simulate correlations, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   5 +
 .../statistics/extended_stats_internal.h      |   7 +
 src/backend/statistics/dependencies.c         | 161 ++++
 src/backend/statistics/extended_stats.c       | 884 ++++++++++++++++--
 src/backend/statistics/mcv.c                  | 192 ++++
 src/backend/statistics/mvdistinct.c           | 160 ++++
 .../regress/expected/stats_export_import.out  | 265 +++++-
 src/test/regress/sql/stats_export_import.sql  | 245 ++++-
 doc/src/sgml/func.sgml                        |  28 +-
 9 files changed, 1874 insertions(+), 73 deletions(-)

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index ec8ce7c3c0..2d12bb9b08 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -6125,6 +6125,11 @@
 { oid => '9161', descr => 'adjust time to local time zone',
   proname => 'timezone', provolatile => 's', prorettype => 'timetz',
   proargtypes => 'timetz', prosrc => 'timetz_at_local' },
+{ oid => '9162',
+  descr => 'statistics: import to extended stats object',
+  proname => 'pg_import_ext_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_ext_stats' },
 { oid => '2039', descr => 'hash',
   proname => 'timestamp_hash', prorettype => 'int4', proargtypes => 'timestamp',
   prosrc => 'timestamp_hash' },
diff --git a/src/include/statistics/extended_stats_internal.h b/src/include/statistics/extended_stats_internal.h
index 8eed9b338d..e325a76e63 100644
--- a/src/include/statistics/extended_stats_internal.h
+++ b/src/include/statistics/extended_stats_internal.h
@@ -70,15 +70,22 @@ typedef struct StatsBuildData
 
 
 extern MVNDistinct *statext_ndistinct_build(double totalrows, StatsBuildData *data);
+extern MVNDistinct *statext_ndistinct_import(Oid relid, Datum ndistinct,
+						bool ndististinct_null, Datum attributes,
+						bool attributes_null);
 extern bytea *statext_ndistinct_serialize(MVNDistinct *ndistinct);
 extern MVNDistinct *statext_ndistinct_deserialize(bytea *data);
 
 extern MVDependencies *statext_dependencies_build(StatsBuildData *data);
+extern MVDependencies *statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null);
 extern bytea *statext_dependencies_serialize(MVDependencies *dependencies);
 extern MVDependencies *statext_dependencies_deserialize(bytea *data);
 
 extern MCVList *statext_mcv_build(StatsBuildData *data,
 								  double totalrows, int stattarget);
+extern MCVList *statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **stats);
 extern bytea *statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats);
 extern MCVList *statext_mcv_deserialize(bytea *data);
 
diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c
index 4752b99ed5..e482eca557 100644
--- a/src/backend/statistics/dependencies.c
+++ b/src/backend/statistics/dependencies.c
@@ -18,6 +18,7 @@
 #include "catalog/pg_operator.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "nodes/nodeFuncs.h"
 #include "nodes/nodes.h"
@@ -27,6 +28,7 @@
 #include "parser/parsetree.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/bytea.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
@@ -1829,3 +1831,162 @@ dependencies_clauselist_selectivity(PlannerInfo *root,
 
 	return s1;
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The dependencies serialization is a string that looks like
+ *       {"2 => 3": 0.258241, "1 => 2": 0.0, ...}
+ *
+ *   The integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we
+ *   match them by name.
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *
+ */
+MVDependencies *
+statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null)
+{
+	MVDependencies *result = NULL;
+
+#define DEPS_NARGS 3
+
+	Oid			argtypes[DEPS_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[DEPS_NARGS] = { relid, dependencies, attributes };
+	char		argnulls[DEPS_NARGS] = { ' ',
+					dependencies_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    dep.depord, "
+		"    da.depattrord, "
+		"    da.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN da.exp_attnum < 0 THEN da.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    dep.degree::float8 AS degree, "
+		"    COUNT(*) OVER (PARTITION BY dep.depord) AS num_attrs, "
+		"    MAX(dep.depord) OVER () AS num_deps "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS dep(attrs, degree, depord) "
+		"CROSS JOIN LATERAL unnest( string_to_array( "
+		"         replace(dep.attrs, ' => ', ', '), ', ')::int2[]) "
+		"     WITH ORDINALITY AS da(exp_attnum, depattrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = da.exp_attnum AND da.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY dep.depord, da.depattrord ";
+
+	enum {
+		DEPS_DEPORD = 0,
+		DEPS_DEPATTRORD,
+		DEPS_EXP_ATTNUM,
+		DEPS_EXP_ATTNAME,
+		DEPS_ATTNUM,
+		DEPS_DEGREE,
+		DEPS_NUM_ATTRS,
+		DEPS_NUM_DEPS,
+		NUM_DEPS_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				ndeps;
+	int				j = 0;
+
+	ret = SPI_execute_with_args(sql, DEPS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		ndeps = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								DEPS_NUM_DEPS+1, &isnull);
+		ndeps = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	if (ndeps == 0)
+		result = (MVDependencies *) palloc0(sizeof(MVDependencies));
+	else
+		result = (MVDependencies *) palloc0(offsetof(MVDependencies, deps)
+												   + (ndeps * sizeof(MVDependency *)));
+
+	result->magic = STATS_DEPS_MAGIC;
+	result->type = STATS_DEPS_TYPE_BASIC;
+	result->ndeps = ndeps;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum			datums[NUM_DEPS_COLS];
+		bool			nulls[NUM_DEPS_COLS];
+		int				natts;
+		int				d;
+		int				a;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[DEPS_DEPORD]);
+		d = DatumGetInt32(datums[DEPS_DEPORD]) - 1;
+		Assert(!nulls[DEPS_DEPATTRORD]);
+		a = DatumGetInt32(datums[DEPS_DEPATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New MVDependnecy */
+			Assert(!nulls[DEPS_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[DEPS_NUM_ATTRS]);
+
+			result->deps[d] = palloc0(offsetof(MVDependency, attributes)
+										+ (natts * sizeof(AttrNumber)));
+
+			result->deps[d]->nattributes = natts;
+			Assert(!nulls[DEPS_DEGREE]);
+			result->deps[d]->degree = DatumGetFloat8(datums[DEPS_DEGREE]);
+		}
+
+		if (!nulls[DEPS_ATTNUM])
+			result->deps[d]->attributes[a] = DatumGetInt16(datums[DEPS_ATTNUM]);
+		else if (nulls[DEPS_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency exported attnum cannot be null")));
+		else if (nulls[DEPS_ATTNUM])
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[DEPS_EXP_ATTNUM]);
+
+			if (nulls[DEPS_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Dependency has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[DEPS_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index c5461514d8..76ae150c5b 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -19,12 +19,14 @@
 #include "access/detoast.h"
 #include "access/genam.h"
 #include "access/htup_details.h"
+#include "access/relation.h"
 #include "access/table.h"
 #include "catalog/indexing.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
 #include "executor/executor.h"
+#include "executor/spi.h"
 #include "commands/defrem.h"
 #include "commands/progress.h"
 #include "miscadmin.h"
@@ -32,6 +34,7 @@
 #include "optimizer/clauses.h"
 #include "optimizer/optimizer.h"
 #include "parser/parsetree.h"
+#include "parser/parse_oper.h"
 #include "pgstat.h"
 #include "postmaster/autovacuum.h"
 #include "statistics/extended_stats_internal.h"
@@ -418,6 +421,83 @@ statext_is_kind_built(HeapTuple htup, char type)
 	return !heap_attisnull(htup, attnum, NULL);
 }
 
+/*
+ * Create a single StatExtEntry from a fetched heap tuple
+ */
+static StatExtEntry *
+create_stat_ext_entry(HeapTuple htup)
+{
+	StatExtEntry *entry;
+	Datum		datum;
+	bool		isnull;
+	int			i;
+	ArrayType  *arr;
+	char	   *enabled;
+	Form_pg_statistic_ext staForm;
+	List	   *exprs = NIL;
+
+	entry = palloc0(sizeof(StatExtEntry));
+	staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
+	entry->statOid = staForm->oid;
+	entry->schema = get_namespace_name(staForm->stxnamespace);
+	entry->name = pstrdup(NameStr(staForm->stxname));
+	entry->stattarget = staForm->stxstattarget;
+	for (i = 0; i < staForm->stxkeys.dim1; i++)
+	{
+		entry->columns = bms_add_member(entry->columns,
+										staForm->stxkeys.values[i]);
+	}
+
+	/* decode the stxkind char array into a list of chars */
+	datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
+								   Anum_pg_statistic_ext_stxkind);
+	arr = DatumGetArrayTypeP(datum);
+	if (ARR_NDIM(arr) != 1 ||
+		ARR_HASNULL(arr) ||
+		ARR_ELEMTYPE(arr) != CHAROID)
+		elog(ERROR, "stxkind is not a 1-D char array");
+	enabled = (char *) ARR_DATA_PTR(arr);
+	for (i = 0; i < ARR_DIMS(arr)[0]; i++)
+	{
+		Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
+			   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
+			   (enabled[i] == STATS_EXT_MCV) ||
+			   (enabled[i] == STATS_EXT_EXPRESSIONS));
+		entry->types = lappend_int(entry->types, (int) enabled[i]);
+	}
+
+	/* decode expression (if any) */
+	datum = SysCacheGetAttr(STATEXTOID, htup,
+							Anum_pg_statistic_ext_stxexprs, &isnull);
+
+	if (!isnull)
+	{
+		char	   *exprsString;
+
+		exprsString = TextDatumGetCString(datum);
+		exprs = (List *) stringToNode(exprsString);
+
+		pfree(exprsString);
+
+		/*
+		 * Run the expressions through eval_const_expressions. This is not
+		 * just an optimization, but is necessary, because the planner
+		 * will be comparing them to similarly-processed qual clauses, and
+		 * may fail to detect valid matches without this.  We must not use
+		 * canonicalize_qual, however, since these aren't qual
+		 * expressions.
+		 */
+		exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
+
+		/* May as well fix opfuncids too */
+		fix_opfuncids((Node *) exprs);
+	}
+
+	entry->exprs = exprs;
+
+	return entry;
+}
+
 /*
  * Return a list (of StatExtEntry) of statistics objects for the given relation.
  */
@@ -443,74 +523,7 @@ fetch_statentries_for_relation(Relation pg_statext, Oid relid)
 
 	while (HeapTupleIsValid(htup = systable_getnext(scan)))
 	{
-		StatExtEntry *entry;
-		Datum		datum;
-		bool		isnull;
-		int			i;
-		ArrayType  *arr;
-		char	   *enabled;
-		Form_pg_statistic_ext staForm;
-		List	   *exprs = NIL;
-
-		entry = palloc0(sizeof(StatExtEntry));
-		staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
-		entry->statOid = staForm->oid;
-		entry->schema = get_namespace_name(staForm->stxnamespace);
-		entry->name = pstrdup(NameStr(staForm->stxname));
-		entry->stattarget = staForm->stxstattarget;
-		for (i = 0; i < staForm->stxkeys.dim1; i++)
-		{
-			entry->columns = bms_add_member(entry->columns,
-											staForm->stxkeys.values[i]);
-		}
-
-		/* decode the stxkind char array into a list of chars */
-		datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
-									   Anum_pg_statistic_ext_stxkind);
-		arr = DatumGetArrayTypeP(datum);
-		if (ARR_NDIM(arr) != 1 ||
-			ARR_HASNULL(arr) ||
-			ARR_ELEMTYPE(arr) != CHAROID)
-			elog(ERROR, "stxkind is not a 1-D char array");
-		enabled = (char *) ARR_DATA_PTR(arr);
-		for (i = 0; i < ARR_DIMS(arr)[0]; i++)
-		{
-			Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
-				   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
-				   (enabled[i] == STATS_EXT_MCV) ||
-				   (enabled[i] == STATS_EXT_EXPRESSIONS));
-			entry->types = lappend_int(entry->types, (int) enabled[i]);
-		}
-
-		/* decode expression (if any) */
-		datum = SysCacheGetAttr(STATEXTOID, htup,
-								Anum_pg_statistic_ext_stxexprs, &isnull);
-
-		if (!isnull)
-		{
-			char	   *exprsString;
-
-			exprsString = TextDatumGetCString(datum);
-			exprs = (List *) stringToNode(exprsString);
-
-			pfree(exprsString);
-
-			/*
-			 * Run the expressions through eval_const_expressions. This is not
-			 * just an optimization, but is necessary, because the planner
-			 * will be comparing them to similarly-processed qual clauses, and
-			 * may fail to detect valid matches without this.  We must not use
-			 * canonicalize_qual, however, since these aren't qual
-			 * expressions.
-			 */
-			exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
-
-			/* May as well fix opfuncids too */
-			fix_opfuncids((Node *) exprs);
-		}
-
-		entry->exprs = exprs;
-
+		StatExtEntry *entry = create_stat_ext_entry(htup);
 		result = lappend(result, entry);
 	}
 
@@ -2636,3 +2649,738 @@ make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
 
 	return result;
 }
+
+static Datum
+import_expressions(Datum stxdexpr, bool stxdexpr_null,
+				   Datum operators, bool operators_null,
+				   VacAttrStats **expr_stats, int nexprs)
+{
+
+#define EXPR_NARGS 2
+
+	Oid			argtypes[EXPR_NARGS] = { JSONBOID, JSONBOID };
+	Datum		args[EXPR_NARGS] = { stxdexpr, operators };
+	char		argnulls[EXPR_NARGS] = {
+					stxdexpr_null ? 'n' : ' ',
+					operators_null ? 'n' : ' ' };
+
+	const char *sql =
+		"WITH exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS eo(oid oid, oprname text) "
+		") "
+		"SELECT s.*, "
+		"       eo1.oprname AS eoprname1, "
+		"       eo2.oprname AS eoprname2, "
+		"       eo3.oprname AS eoprname3, "
+		"       eo4.oprname AS eoprname4, "
+		"       eo5.oprname AS eoprname5 "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = s.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = s.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = s.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = s.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = s.staop5 ";
+
+	enum
+	{
+		EXPR_ATTNUM = 0,
+		EXPR_STAINHERIT,
+		EXPR_STANULLFRAC,
+		EXPR_STAWIDTH,
+		EXPR_STADISTINCT,
+		EXPR_STAKIND1,
+		EXPR_STAKIND2,
+		EXPR_STAKIND3,
+		EXPR_STAKIND4,
+		EXPR_STAKIND5,
+		EXPR_STAOP1,
+		EXPR_STAOP2,
+		EXPR_STAOP3,
+		EXPR_STAOP4,
+		EXPR_STAOP5,
+		EXPR_STACOLL1,
+		EXPR_STACOLL2,
+		EXPR_STACOLL3,
+		EXPR_STACOLL4,
+		EXPR_STACOLL5,
+		EXPR_STANUMBERS1,
+		EXPR_STANUMBERS2,
+		EXPR_STANUMBERS3,
+		EXPR_STANUMBERS4,
+		EXPR_STANUMBERS5,
+		EXPR_STAVALUES1,
+		EXPR_STAVALUES2,
+		EXPR_STAVALUES3,
+		EXPR_STAVALUES4,
+		EXPR_STAVALUES5,
+		EXPR_EOPRNAME1,
+		EXPR_EOPRNAME2,
+		EXPR_EOPRNAME3,
+		EXPR_EOPRNAME4,
+		EXPR_EOPRNAME5,
+		NUM_EXPR_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				e;
+
+	ArrayBuildState *astate = NULL;
+
+	Relation	pgsd;
+	HeapTuple	pgstup;
+	Oid			pgstypoid;
+	FmgrInfo	finfo;
+
+	pgsd = table_open(StatisticRelationId, RowExclusiveLock);
+	pgstypoid = get_rel_type_id(StatisticRelationId);
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	if (!OidIsValid(pgstypoid))
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("relation \"%s\" does not have a composite type",
+						"pg_statistic")));
+
+	ret = SPI_execute_with_args(sql, EXPR_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (nexprs != tuptable->numvals)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export expected %d stxdexpr rows but found %lu",
+					 nexprs, tuptable->numvals)));
+
+	if (nexprs == 0)
+		astate = accumArrayResult(astate,
+								  (Datum) 0,
+								  true,
+								  pgstypoid,
+								  CurrentMemoryContext);
+
+	for (e = 0; e < nexprs; e++)
+	{
+		Datum	values[Natts_pg_statistic] = { 0 };
+		bool	nulls[Natts_pg_statistic] = { false };
+
+		Datum	rs_datums[NUM_EXPR_COLS];
+		bool	rs_nulls[NUM_EXPR_COLS];
+
+		VacAttrStats   *stats = expr_stats[e];
+
+		Oid 	basetypoid;
+		Oid		ltopr;
+		Oid 	baseltopr;
+		Oid		eqopr;
+		Oid 	baseeqopr;
+		int 	k;
+
+		/*
+		 * If if the stat is an array, then we want the base element
+		 * type. This mimics the calculation in get_attrinfo().
+		 */
+		get_sort_group_operators(stats->attrtypid,
+								 false, false, false,
+								 &ltopr, &eqopr, NULL,
+								 NULL);
+		basetypoid = get_base_element_type(stats->attrtypid);
+		if (basetypoid == InvalidOid)
+			basetypoid = stats->attrtypid;
+		get_sort_group_operators(basetypoid,
+								 false, false, false,
+								 &baseltopr, &baseeqopr, NULL,
+								 NULL);
+
+		heap_deform_tuple(tuptable->vals[e], tuptable->tupdesc,
+						  rs_datums, rs_nulls);
+
+		/* These values are not derived from either vac stats or exported stats */
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
+
+		if (rs_nulls[EXPR_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stanullfrac")));
+
+		if (rs_nulls[EXPR_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stawidth")));
+
+		if (rs_nulls[EXPR_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = rs_datums[EXPR_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = rs_datums[EXPR_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = rs_datums[EXPR_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind = 0;
+			Oid		op = InvalidOid;
+
+			if (!rs_nulls[EXPR_STAKIND1 + k])
+			{
+				kind = Int16GetDatum(rs_datums[EXPR_STAKIND1 + k]);
+
+				if (!rs_nulls[EXPR_EOPRNAME1 + k])
+				{
+					char *s = TextDatumGetCString(rs_datums[EXPR_EOPRNAME1 + k]);
+
+					if (strcmp(s, "=") == 0)
+					{
+						/*
+						 * MCELEM stat arrays are of the same type as the
+						 * array base element type and are eqopr
+						 */
+						if ((kind == STATISTIC_KIND_MCELEM) ||
+							(kind == STATISTIC_KIND_DECHIST))
+							op = baseeqopr;
+						else
+							op = eqopr;
+					}
+					else if (strcmp(s, "<") == 0)
+						op = ltopr;
+					else
+						op = InvalidOid;
+
+					pfree(s);
+				}
+			}
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = kind;
+			values[Anum_pg_statistic_staop1 - 1 + k] = op;
+
+			/* rely on vacattrstat */
+			values[Anum_pg_statistic_stacoll1 - 1 + k] =
+				ObjectIdGetDatum(stats->stacoll[k]);
+
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_datums[EXPR_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_nulls[EXPR_STANUMBERS1 + k];
+
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] =
+				rs_nulls[EXPR_STAVALUES1 + k];
+			if (rs_nulls[EXPR_STAVALUES1 + k])
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			else
+			{
+				char *s = TextDatumGetCString(rs_datums[EXPR_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(basetypoid),
+								  Int32GetDatum(stats->attrtypmod));
+
+				pfree(s);
+			}
+		}
+
+		pgstup = heap_form_tuple(RelationGetDescr(pgsd), values, nulls);
+
+		astate = accumArrayResult(astate,
+								  heap_copy_tuple_as_datum(pgstup, RelationGetDescr(pgsd)),
+								  false,
+								  pgstypoid,
+								  CurrentMemoryContext);
+	}
+
+	table_close(pgsd, RowExclusiveLock);
+
+	return makeArrayResult(astate, CurrentMemoryContext);
+}
+
+/*
+ * Import statistics for a given extended statistics object.
+ *
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "stxoid": number, -- pg_stat_ext.stxoid
+ *   "stxname": string, -- pg_stat_ext.stxname
+ *   "stxnspname": string, -- schema name for the statistics object
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   -- stxkeys cast to text to aid array_in()
+ *   "stxkeys": string, -- pg_statistic_ext.stxkind::text
+ *   -- stxndistinct and stxdndepencies only on v10-v11
+ *   "stxndistinct": string, -- pg_statistic_ext.stxndistinct::text
+ *   "stxdependencies": string, -- pg_statistic_ext.stxdependencies::text
+ *   -- data is on v12+
+ *   "data": [
+ *     {
+ *       -- stxdinherit is on v15+
+ *       "stxdinherit": bool, -- pg_statistic_ext_data.stxdinherit
+ *       -- stxdndistinct and stxddependencies are on v12+
+ *       "stxdndistinct": text, -- pg_statistic_ext_data.stxdndisinct::text
+ *       "stxddependencies": text, -- pg_statistic_ext_data.stxddepencies::text
+ *       -- stxdexpr is on v12+
+ *       "stxdmcv": [
+ *         {
+ *           "index": number,
+ *           "nulls": [bool],
+ *           "values": [text],
+ *           "frequency": number,
+ *           "base_frequency": number
+ *         }
+ *       ],
+ *       -- stxdexpr is on v14+
+ *       "stxdexpr": [
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *       ]
+ *     }
+ *   ],
+ *   "types": [
+ *     -- export of all pg_type referenced in this json doc
+ *	   {
+ *        "oid": number, -- pg_type.oid
+ *        "typname": string, -- pg_type.typname
+ *        "nspname": string -- schema name for the pg_type
+ *     }
+ *   ],
+ *   "collations": [
+ *     -- export all pg_collation reference in this json doc
+ *     {
+ *        "oid": number, -- pg_collation.oid
+ *        "collname": string, -- pg_collation.collname
+ *        "nspname": string -- schema name for the pg_collation
+ *     }
+ *   ],
+ *   "operators": [
+ *     -- export all pg_operator reference in this json doc
+ *     {
+ *        "oid": number, -- pg_operator.oid
+ *        "collname": string, -- pg_oprname
+ *        "nspname": string -- schema name for the pg_operator
+ *     }
+ *   ],
+ *   "attributes": [
+ *     -- export all pg_attribute for the exported relation
+ *     {
+ *        "attnum": number, -- pg_attribute.attnum
+ *        "attname": string, -- pg_attribute.attname
+ *        "atttypid": number, -- pg_attribute.atttypid
+ *        "attcollation": number -- pg_attribute.attcollation
+ *     }
+ *   ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+ *
+ * Statistics imported from version 15 and higher can potentially have two
+ * result rows, one with stxdinherit = false and one for stxdinherit = true
+ *
+ */
+Datum
+pg_import_ext_stats(PG_FUNCTION_ARGS)
+{
+	const char *bq_sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    stxoid Oid, "
+		"    reloid Oid, "
+		"    stxname text, "
+		"    stxnspname text, "
+		"    relname text, "
+		"    nspname text, "
+		"    stxkeys text, "
+		"    stxkind text, "
+		"    stxndistinct text, "
+		"    stxdependencies text, "
+		"    data jsonb, "
+		"    attributes jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    types jsonb) ";
+
+	enum {
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_STXOID,
+		BQ_RELOID,
+		BQ_STXNAME,
+		BQ_STXNSPNAME,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_STXKEYS,
+		BQ_STXKIND,
+		BQ_STXNDISTINCT,
+		BQ_STXDEPENDENCIES,
+		BQ_DATA,
+		BQ_ATTRIBUTES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_TYPES,
+		NUM_BQ_COLS
+	};
+
+	/* All versions of the STXD query have the same column signature */
+	enum {
+		STXD_INHERIT = 0,
+		STXD_NDISTINCT,
+		STXD_DEPENDENCIES,
+		STXD_MCV,
+		STXD_EXPR,
+		NUM_STXD_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid		stxid;
+	bool	validate;
+	bool	require_match_oids;
+
+	Oid		bq_argtypes[BQ_NARGS] = { JSONBOID };
+	Datum	bq_args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Relation	rel;
+	TupleDesc	tupdesc;
+	int			natts;
+
+	HeapTuple	etup;
+	Relation	sd;
+
+	Form_pg_statistic_ext	stxform;
+
+	StatExtEntry   *stxentry;
+	VacAttrStats  **relstats; /* all relations attributes */
+	VacAttrStats  **extstats; /* entries relevenat to the extstat */
+	VacAttrStats  **expr_stats; /* expressions in the extstat */
+	int				nexprs;
+	int				ncols;
+
+	Datum	bq_datums[NUM_BQ_COLS];
+	bool	bq_nulls[NUM_BQ_COLS];
+
+	int		i;
+	int32	server_version_num;
+	int32	current_version_num;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("extended statistics oid cannot be NULL")));
+	stxid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	bq_args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	etup = SearchSysCacheCopy1(STATEXTOID, ObjectIdGetDatum(stxid));
+	if (!HeapTupleIsValid(etup))
+		elog(ERROR, "pg_statistic_ext entry for oid %u vanished during statistics import",
+			 stxid);
+
+	stxform = (Form_pg_statistic_ext) GETSTRUCT(etup);
+
+	rel = relation_open(stxform->stxrelid, ShareUpdateExclusiveLock);
+
+	tupdesc = RelationGetDescr(rel);
+	natts = tupdesc->natts;
+
+	relstats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
+	for (i = 0; i < natts; i++)
+		relstats[i] = examine_rel_attribute(rel, i+1, NULL);
+
+	stxentry = create_stat_ext_entry(etup);
+	extstats = lookup_var_attr_stats(rel, stxentry->columns, stxentry->exprs,
+									 natts, relstats);
+
+	/* only the stats that were derived from pg_statistic_ext */
+	ncols = bms_num_members(stxentry->columns);
+	expr_stats = &extstats[ncols];
+	nexprs = list_length(stxentry->exprs);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(bq_sql, BQ_NARGS, bq_argtypes, bq_args,
+								NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("pg_statistic_ext export JSON should return exactly one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, bq_datums, bq_nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (bq_nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (bq_nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(bq_datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(bq_datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	if (validate)
+	{
+		validate_exported_types(bq_datums[BQ_TYPES], bq_nulls[BQ_TYPES]);
+		validate_exported_collations(bq_datums[BQ_COLLATIONS], bq_nulls[BQ_COLLATIONS]);
+		validate_exported_operators(bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS]);
+		validate_exported_attributes(bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+	}
+
+	if (server_version_num >= 120000)
+	{
+		/* pg_statistic_ext_data export for modern versions */
+
+#define STXD_NARGS 1
+
+		Oid		stxd_argtypes[STXD_NARGS] = { JSONBOID };
+		Datum	stxd_args[STXD_NARGS] = { bq_datums[BQ_DATA] };
+		char	stxd_nulls[STXD_NARGS] = { bq_nulls[BQ_DATA] ? 'n' : ' ' };
+
+		const char *stxd_sql =
+			"SELECT d.* "
+			"FROM jsonb_to_recordset($1) AS d ( "
+			"    stxdinherit bool, "
+			"    stxdndistinct text, "
+			"    stxddependencies text, "
+			"    stxdmcv jsonb, "
+			"    stxdexpr jsonb) "
+			"ORDER BY d.stxdinherit ";
+
+		/* Versions 12+ cannot have ndistinct or dependencies on the base query */
+		if (!bq_nulls[BQ_STXNDISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxndistinct not allowed on exports of servers v12 and later"),
+					 errhint("Use stxdndistinct instead")));
+
+		if(!bq_nulls[BQ_STXDEPENDENCIES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdependencies not allowed on exports of servers v12 and later"),
+					 errhint("Use stxddependencies instead")));
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 0);
+#undef STXD_NARGS
+	}
+	else
+	{
+#define STXD_NARGS 2
+		Oid		stxd_argtypes[STXD_NARGS] = {
+					TEXTOID,
+					TEXTOID };
+		Datum	stxd_args[STXD_NARGS] = {
+					bq_datums[BQ_STXNDISTINCT],
+					bq_datums[BQ_STXDEPENDENCIES] };
+		char	stxd_nulls[STXD_NARGS] = {
+					bq_nulls[BQ_STXNDISTINCT] ? 'n' : ' ',
+					bq_nulls[BQ_DATA]  ? 'n' : ' ' };
+
+		/* pg_statistic_ext_data export for versions prior to the table existing */
+		const char *stxd_sql =
+			"SELECT "
+			"	NULL::boolean AS stxdinherit, "
+			"   $1 AS stxdndistinct, "
+			"   $2 AS stxddependencies, "
+			"   NULL::jsonb AS stxdmcv, "
+			"   NULL::jsonb AS stxdexpr ";
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 2);
+
+#undef STXD_NARGS
+	}
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	/* overwrite previous tuptable */
+	tuptable = SPI_tuptable;
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum			stxd_datums[NUM_BQ_COLS];
+		bool			stxd_nulls[NUM_BQ_COLS];
+		bool			inh;
+		MCVList		   *mcvlist;
+		MVDependencies *dependencies;
+		MVNDistinct	   *ndistinct;
+		Datum			exprs;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, stxd_datums,
+						  stxd_nulls);
+
+		if ((!stxd_nulls[STXD_MCV]) && (server_version_num < 120000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdmv not allowed on exports of servers berfore v12")));
+
+		if ((!stxd_nulls[STXD_EXPR]) && (server_version_num < 140000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdexpr not allowed on exports of servers berfore v14")));
+
+		if ((!stxd_nulls[STXD_INHERIT]) && (server_version_num < 150000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Extended statistics from servers prior to v15 cannot contain inherited stats")));
+
+		/* Versions prior to v15 never have stxdinhert set */
+		if (stxd_nulls[STXD_INHERIT])
+			inh = false;
+		else
+			inh = DatumGetBool(stxd_datums[STXD_INHERIT]);
+
+		ndistinct = statext_ndistinct_import(stxform->stxrelid,
+						stxd_datums[STXD_NDISTINCT], stxd_nulls[STXD_NDISTINCT],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		dependencies = statext_dependencies_import(stxform->stxrelid,
+						stxd_datums[STXD_DEPENDENCIES],
+						stxd_nulls[STXD_DEPENDENCIES],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		mcvlist = statext_mcv_import(stxd_datums[STXD_MCV], stxd_nulls[STXD_MCV],
+									 extstats);
+
+		exprs = import_expressions(stxd_datums[STXD_EXPR], stxd_nulls[STXD_EXPR],
+								   bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS],
+								   expr_stats, nexprs);
+
+		statext_store(stxentry->statOid, inh, ndistinct, dependencies, mcvlist, exprs, extstats);
+	}
+
+	relation_close(rel, NoLock);
+	table_close(sd, RowExclusiveLock);
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index 6255cd1f4f..3bafde83d6 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -20,6 +20,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "fmgr.h"
 #include "funcapi.h"
 #include "nodes/nodeFuncs.h"
@@ -2177,3 +2178,194 @@ mcv_clause_selectivity_or(PlannerInfo *root, StatisticExtInfo *stat,
 
 	return s;
 }
+
+/*
+ * statext_mcv_import
+ *
+ * The mcv serialization is the json equivalent of the
+ * pg_mcv_list_items() result set:
+ * [
+ *   {
+ *     "index": number,
+ *     "values": [string],
+ *     "nulls": [bool],
+ *     "frequency": number,
+ *     "base_frequency": number
+ *   }
+ * ]
+ *
+ * The values are text strings that must be converted into datums of the type
+ * appropriate for their corresponding dimension. This means that we must
+ * cast individual datums rather than trying to use array_in().
+ *
+ */
+MCVList *
+statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **extstats)
+{
+	const char *sql =
+		"SELECT m.*, array_length(m.nulls,1) AS ndims "
+		"FROM jsonb_to_recordset($1) AS m(index integer, values text[], "
+		"         nulls boolean[], frequency float8, base_frequency float8) "
+		"ORDER BY m.index ";
+
+	enum {
+		MCVS_INDEX = 0,
+		MCVS_VALUES,
+		MCVS_NULLS,
+		MCVS_FREQUENCY,
+		MCVS_BASE_FREQUENCY,
+		MCVS_NDIMS,
+		NUM_MCVS_COLS
+	};
+
+#define MCVS_NARGS 1
+
+	Oid		argtypes[MCVS_NARGS] = { JSONBOID };
+	Datum	args[MCVS_NARGS] = { mcv };
+	char	argnulls[MCVS_NARGS] = { mcv_null ? 'n' : ' ' };
+	int		nitems = 0;
+	int		ndims = 0;
+	int		ret;
+	int		i;
+
+	MCVList		   *mcvlist;
+	SPITupleTable  *tuptable;
+	Oid				ioparams[STATS_MAX_DIMENSIONS];
+	FmgrInfo		finfos[STATS_MAX_DIMENSIONS];
+
+	ret = SPI_execute_with_args(sql, MCVS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		/* ndims will be same for all rows, so just check first one */
+		bool	isnull;
+		Datum	d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								  MCVS_NDIMS+1, &isnull);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of mcv dimensions")));
+
+		ndims = DatumGetInt32(d);
+		nitems = tuptable->numvals;
+	}
+
+	mcvlist = (MCVList *) palloc0(offsetof(MCVList, items) +
+								  (sizeof(MCVItem) * nitems));
+
+	mcvlist->magic = STATS_MCV_MAGIC;
+	mcvlist->type = STATS_MCV_TYPE_BASIC;
+	mcvlist->nitems = nitems;
+	mcvlist->ndimensions = ndims;
+
+	/* We will need these input functions $nitems times. */
+	for (i = 0; i < ndims; i++)
+	{
+		Oid		typid = extstats[i]->attrtypid;
+		Oid		infunc;
+
+		mcvlist->types[i] = typid;
+		getTypeInputInfo(typid, &infunc, &ioparams[i]);
+		fmgr_info(infunc, &finfos[i]);
+	}
+
+	for (i = 0; i < nitems; i++)
+	{
+		MCVItem	   *item = &mcvlist->items[i];
+		Datum		datums[NUM_MCVS_COLS];
+		bool		nulls[NUM_MCVS_COLS];
+		ArrayType  *arr;
+		Datum      *elems;
+		bool       *elnulls;
+		int         nelems;
+
+		int			d;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, datums, nulls);
+
+		if (nulls[MCVS_VALUES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"values")));
+		if (nulls[MCVS_NULLS])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"nulls")));
+		if (nulls[MCVS_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"frequency")));
+		if (nulls[MCVS_BASE_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"base_frequency")));
+
+		item->frequency = DatumGetFloat8(datums[MCVS_FREQUENCY]);
+		item->base_frequency = DatumGetFloat8(datums[MCVS_BASE_FREQUENCY]);
+		item->values = (Datum *) palloc(sizeof(Datum) * ndims);
+		item->isnull = (bool *) palloc(sizeof(bool) * ndims);
+
+		arr = DatumGetArrayTypeP(datums[MCVS_NULLS]);
+		deconstruct_array(arr, BOOLOID, 1, true, 'c', &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"nulls", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			if (elnulls[d])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("extended statistic mcv %s array cannot contain NULL values",
+								"nulls")));
+			item->isnull[d] = DatumGetBool(elems[d]);
+		}
+
+		arr = DatumGetArrayTypeP(datums[MCVS_VALUES]);
+		deconstruct_array_builtin(arr, TEXTOID, &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"values", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			/* if the element is a known NULL, nothing to decode */
+			if (item->isnull[d])
+				item->values[d] = (Datum) 0;
+			else
+			{
+				char   *s;
+
+				if (elnulls[d])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("extended statistic mcv nulls array in conflict with values array")));
+
+				s = TextDatumGetCString(elems[d]);
+
+				item->values[d] = InputFunctionCall(&finfos[d], s, ioparams[d],
+													extstats[d]->attrtypmod);
+				pfree(s);
+			}
+		}
+	}
+
+	return mcvlist;
+}
diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c
index ee1134cc37..d84eee47ee 100644
--- a/src/backend/statistics/mvdistinct.c
+++ b/src/backend/statistics/mvdistinct.c
@@ -28,9 +28,11 @@
 #include "access/htup_details.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -698,3 +700,161 @@ generate_combinations(CombinationGenerator *state)
 
 	pfree(current);
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The ndinstinct serialization is a string that looks like
+ *       {"2, 3": 1521, "3, -1": 4}
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *   The key side integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we match
+ *   them by name.
+ *
+ *   Negative integers represent expressions columns that have no
+ *   corresponding match in the exported attributes. We leave those
+ *   attnums as-is. Positive integers are looked up in the exported
+ *   attributes and the attname there is then compared to pg_attribute
+ *   names in the underlying table, and that tuples attnum is used instead.
+ */
+MVNDistinct *
+statext_ndistinct_import(Oid relid, Datum ndistinct, bool ndistinct_null,
+						 Datum attributes, bool attributes_null)
+{
+	MVNDistinct	   *result;
+	int				nitems;
+
+#define NDIST_NARGS 3
+
+	Oid			argtypes[NDIST_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[NDIST_NARGS] = { relid, ndistinct , attributes };
+	char		argnulls[NDIST_NARGS] = { ' ',
+					ndistinct_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    i.itemord, "
+		"    a.attrord, "
+		"    a.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN a.exp_attnum < 0 THEN a.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    i.ndistinct::float8 AS ndistinct, "
+		"    COUNT(*) OVER (PARTITION BY i.itemord) AS num_attrs, "
+		"    MAX(i.itemord) OVER () AS num_items "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS i(attrlist, ndistinct, itemord) "
+		"CROSS JOIN LATERAL unnest(string_to_array(i.attrlist, ', ')::int2[]) "
+		"     WITH ORDINALITY AS a(exp_attnum, attrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = a.exp_attnum AND a.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY i.itemord, a.attrord ";
+
+	enum {
+		NDIST_ITEMORD = 0,
+		NDIST_ATTRORD,
+		NDIST_EXP_ATTNUM,
+		NDIST_EXP_ATTNAME,
+		NDIST_ATTNUM,
+		NDIST_NDISTINCT,
+		NDIST_NUM_ATTRS,
+		NDIST_NUM_ITEMS,
+		NUM_NDIST_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				j;
+
+	ret = SPI_execute_with_args(sql, NDIST_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		nitems = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								NDIST_NUM_ITEMS+1, &isnull);
+		nitems = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	result = palloc(offsetof(MVNDistinct, items) +
+					(nitems * sizeof(MVNDistinctItem)));
+	result->magic = STATS_NDISTINCT_MAGIC;
+	result->type = STATS_NDISTINCT_TYPE_BASIC;
+	result->nitems = nitems;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum	datums[NUM_NDIST_COLS];
+		bool	nulls[NUM_NDIST_COLS];
+		int		i;
+		int		a;
+		int		natts;
+
+		MVNDistinctItem *item;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[NDIST_ITEMORD]);
+		i = DatumGetInt32(datums[NDIST_ITEMORD]) - 1;
+		item = &result->items[i];
+		Assert(!nulls[NDIST_ATTRORD]);
+		a = DatumGetInt32(datums[NDIST_ATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New item */
+			Assert(!nulls[NDIST_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[NDIST_NUM_ATTRS]);
+			item->nattributes = natts;
+			item->attributes = palloc(sizeof(AttrNumber) * natts);
+			Assert(!nulls[NDIST_NDISTINCT]);
+			item->ndistinct = DatumGetFloat8(datums[NDIST_NDISTINCT]);
+		}
+
+		if (!nulls[NDIST_ATTNUM])
+			item->attributes[a] =
+				DatumGetInt16(datums[NDIST_ATTNUM]);
+		else if (nulls[NDIST_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ndistinct exported attnum cannot be null")));
+		else
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[NDIST_EXP_ATTNUM]);
+
+			if (nulls[NDIST_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("ndistinct has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[NDIST_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
index 5ab51c5aa0..9d17947583 100644
--- a/src/test/regress/expected/stats_export_import.out
+++ b/src/test/regress/expected/stats_export_import.out
@@ -22,6 +22,7 @@ SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.comple
 UNION ALL
 SELECT 4, 'four', NULL, NULL;
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
 -- Capture pg_statistic values for table and index
@@ -44,6 +45,25 @@ FROM stats_export_import.pg_statistic_capture;
      5
 (1 row)
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ count 
+-------
+     1
+(1 row)
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -323,6 +343,173 @@ WHERE :'debug'::boolean;
 ------------------
 (0 rows)
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+ ext_stats_json 
+----------------
+(0 rows)
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
@@ -334,12 +521,14 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
--- Create empty copy tables
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Verify no stats for these new tables
 SELECT COUNT(*)
 FROM pg_statistic
@@ -475,6 +664,19 @@ SELECT pg_import_rel_stats(
  t
 (1 row)
 
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        true)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ pg_import_ext_stats 
+---------------------
+ t
+(1 row)
+
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
         stakind1, stakind2, stakind3, stakind4, stakind5,
@@ -528,3 +730,62 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
index 9a80eebeec..cbe94b9273 100644
--- a/src/test/regress/sql/stats_export_import.sql
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -26,6 +26,7 @@ UNION ALL
 SELECT 4, 'four', NULL, NULL;
 
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
@@ -47,6 +48,22 @@ WHERE starelid IN ('stats_export_import.test'::regclass,
 SELECT COUNT(*)
 FROM stats_export_import.pg_statistic_capture;
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -322,19 +339,186 @@ WHERE r.oid = 'stats_export_import.is_odd'::regclass
 SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
 WHERE :'debug'::boolean;
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
 
--- Create empty copy tables
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Verify no stats for these new tables
 SELECT COUNT(*)
@@ -456,6 +640,15 @@ SELECT pg_import_rel_stats(
         true,
         true);
 
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        true)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
         stakind1, stakind2, stakind3, stakind4, stakind5,
@@ -497,3 +690,51 @@ FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
+
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index d16983dff3..c225d937e9 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28735,12 +28735,38 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
        </para>
        <para>
         If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
-        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        then the import will fail if the imported oids for <structname>pg_type</structname>,
         <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
         not match the values specified in <parameter>relation_json</parameter>, as would be expected
         in a binary upgrade. These assumptions would not be true when restoring from a dump.
        </para></entry>
       </row>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_ext_stats</primary>
+        </indexterm>
+        <function>pg_import_ext_stats</function> ( <parameter>extended statisticss object</parameter> <type>oid</type>, <parameter>extended_stats</parameter> <type>jsonb</type> <parameter>validate</parameter> <type>boolean</type>, <parameter>require_match_oids</parameter> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_statistic_ext_data</structname> rows for the
+        <structfield>oid</structfield> matching
+        <parameter>extended statistics object</parameter> are transactionally
+        replaced with the values found in <parameter>extended_stats</parameter>.
+        The purpose of this function is to apply statistics values in an upgrade
+        situation that are "good enough" for system operation until they are
+        replaced by the next auto-analyze. This function could be used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>extended_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para></entry>
+      </row>
      </tbody>
     </tgroup>
    </table>
-- 
2.43.0

From 101c6476df3b7e9d4f199b4c4a149e1dfeebd51c Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 1 Feb 2024 20:45:05 -0500
Subject: [PATCH v4 3/3] Add pg_export_stats, pg_import_stats

These are reference programs designed to aid the testing of the
functions pg_import_rel_stats() and pg_import_ext_stats(), bringing in
statistics from  older versions of postgresql.

The ultimate goal is to move the queries into pg_dump.
---
 src/bin/scripts/.gitignore        |    2 +
 src/bin/scripts/Makefile          |    4 +-
 src/bin/scripts/pg_export_stats.c | 1012 +++++++++++++++++++++++++++++
 src/bin/scripts/pg_import_stats.c |  477 ++++++++++++++
 4 files changed, 1494 insertions(+), 1 deletion(-)
 create mode 100644 src/bin/scripts/pg_export_stats.c
 create mode 100644 src/bin/scripts/pg_import_stats.c

diff --git a/src/bin/scripts/.gitignore b/src/bin/scripts/.gitignore
index 0f23fe0004..1b9addb339 100644
--- a/src/bin/scripts/.gitignore
+++ b/src/bin/scripts/.gitignore
@@ -6,5 +6,7 @@
 /reindexdb
 /vacuumdb
 /pg_isready
+/pg_export_stats
+/pg_import_stats
 
 /tmp_check/
diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile
index 9633c99136..7550c69d81 100644
--- a/src/bin/scripts/Makefile
+++ b/src/bin/scripts/Makefile
@@ -16,7 +16,7 @@ subdir = src/bin/scripts
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready
+PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready pg_export_stats pg_import_stats
 
 override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
 LDFLAGS_INTERNAL += -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport)
@@ -41,6 +41,8 @@ install: all installdirs
 	$(INSTALL_PROGRAM) vacuumdb$(X)   '$(DESTDIR)$(bindir)'/vacuumdb$(X)
 	$(INSTALL_PROGRAM) reindexdb$(X)  '$(DESTDIR)$(bindir)'/reindexdb$(X)
 	$(INSTALL_PROGRAM) pg_isready$(X) '$(DESTDIR)$(bindir)'/pg_isready$(X)
+	$(INSTALL_PROGRAM) pg_export_stats$(X) '$(DESTDIR)$(bindir)'/pg_export_stats$(X)
+	$(INSTALL_PROGRAM) pg_import_stats$(X) '$(DESTDIR)$(bindir)'/pg_import_stats$(X)
 
 installdirs:
 	$(MKDIR_P) '$(DESTDIR)$(bindir)'
diff --git a/src/bin/scripts/pg_export_stats.c b/src/bin/scripts/pg_export_stats.c
new file mode 100644
index 0000000000..c07450d1a9
--- /dev/null
+++ b/src/bin/scripts/pg_export_stats.c
@@ -0,0 +1,1012 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_export_stats
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_export_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+static void help(const char *progname);
+
+/*
+ * Versions 12+ have the same rel stats layout
+ */
+const char *export_rel_query_v12 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    NULL::text AS ext_stats_name, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'reltuples', r.reltuples, "
+	"        'relpages', r.relpages, "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_type AS t "
+	"                JOIN pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_operator AS o "
+	"                JOIN pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.oid "
+	"                    FROM pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ), "
+	"        'statistics', "
+	"        ( "
+	"            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                     s.staattnum, "
+	"                     s.stainherit, "
+	"                     s.stanullfrac, "
+	"                     s.stawidth, "
+	"                     s.stadistinct, "
+	"                     s.stakind1, "
+	"                     s.stakind2, "
+	"                     s.stakind3, "
+	"                     s.stakind4, "
+	"                     s.stakind5, "
+	"                     s.staop1, "
+	"                     s.staop2, "
+	"                     s.staop3, "
+	"                     s.staop4, "
+	"                     s.staop5, "
+	"                     s.stacoll1, "
+	"                     s.stacoll2, "
+	"                     s.stacoll3, "
+	"                     s.stacoll4, "
+	"                     s.stacoll5, "
+	"                     s.stanumbers1::text AS stanumbers1, "
+	"                     s.stanumbers2::text AS stanumbers2, "
+	"                     s.stanumbers3::text AS stanumbers3, "
+	"                     s.stanumbers4::text AS stanumbers4, "
+	"                     s.stanumbers5::text AS stanumbers5, "
+	"                     s.stavalues1::text AS stavalues1, "
+	"                     s.stavalues2::text AS stavalues2, "
+	"                     s.stavalues3::text AS stavalues3, "
+	"                     s.stavalues4::text AS stavalues4, "
+	"                     s.stavalues5::text AS stavalues5 "
+	"                FROM pg_statistic AS s "
+	"                WHERE s.starelid = r.oid "
+	"            ) AS sr "
+	"        ) "
+	"    ) AS stats_json "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+/*
+ * Versions 10-11 are missing the pg_statistic.stacollN columns
+ */
+const char *export_rel_query_v10 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    NULL::text AS ext_stats_name, "
+	"    current_setting('server_version_num')::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_type AS t "
+	"                JOIN pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_operator AS o "
+	"                JOIN pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.oid "
+	"                    FROM pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ), "
+	"        'statistics', "
+	"        ( "
+	"            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                     s.staattnum, "
+	"                     s.stainherit, "
+	"                     s.stanullfrac, "
+	"                     s.stawidth, "
+	"                     s.stadistinct, "
+	"                     s.stakind1, "
+	"                     s.stakind2, "
+	"                     s.stakind3, "
+	"                     s.stakind4, "
+	"                     s.stakind5, "
+	"                     s.staop1, "
+	"                     s.staop2, "
+	"                     s.staop3, "
+	"                     s.staop4, "
+	"                     s.staop5, "
+	"                     s.stanumbers1::text AS stanumbers1, "
+	"                     s.stanumbers2::text AS stanumbers2, "
+	"                     s.stanumbers3::text AS stanumbers3, "
+	"                     s.stanumbers4::text AS stanumbers4, "
+	"                     s.stanumbers5::text AS stanumbers5, "
+	"                     s.stavalues1::text AS stavalues1, "
+	"                     s.stavalues2::text AS stavalues2, "
+	"                     s.stavalues3::text AS stavalues3, "
+	"                     s.stavalues4::text AS stavalues4, "
+	"                     s.stavalues5::text AS stavalues5 "
+	"                FROM pg_statistic AS s "
+	"                WHERE s.starelid = r.oid "
+	"            ) AS sr "
+	"        ) "
+	"    ) AS stats_json "
+	"FROM pg_class AS r "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+
+const char *export_ext_query_v15 =
+/* v15+ have the same format */
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(dr ORDER by dr.stxdinherit) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdinherit, "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv, "
+	"                    ( "
+	"                        SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"                        FROM ( "
+	"                            SELECT "
+	"                                 s.staattnum, "
+	"                                 s.stainherit, "
+	"                                 s.stanullfrac, "
+	"                                 s.stawidth, "
+	"                                 s.stadistinct, "
+	"                                 s.stakind1, "
+	"                                 s.stakind2, "
+	"                                 s.stakind3, "
+	"                                 s.stakind4, "
+	"                                 s.stakind5, "
+	"                                 s.staop1, "
+	"                                 s.staop2, "
+	"                                 s.staop3, "
+	"                                 s.staop4, "
+	"                                 s.staop5, "
+	"                                 s.stacoll1, "
+	"                                 s.stacoll2, "
+	"                                 s.stacoll3, "
+	"                                 s.stacoll4, "
+	"                                 s.stacoll5, "
+	"                                 s.stanumbers1::text AS stanumbers1, "
+	"                                 s.stanumbers2::text AS stanumbers2, "
+	"                                 s.stanumbers3::text AS stanumbers3, "
+	"                                 s.stanumbers4::text AS stanumbers4, "
+	"                                 s.stanumbers5::text AS stanumbers5, "
+	"                                 s.stavalues1::text AS stavalues1, "
+	"                                 s.stavalues2::text AS stavalues2, "
+	"                                 s.stavalues3::text AS stavalues3, "
+	"                                 s.stavalues4::text AS stavalues4, "
+	"                                 s.stavalues5::text AS stavalues5 "
+	"                            FROM unnest(sd.stxdexpr) AS s "
+	"                            WHERE sd.stxdexpr IS NOT NULL "
+	"                        ) AS sr "
+	"                    ) AS stxdexpr "
+	"                FROM pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) AS dr "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_type AS t "
+	"                JOIN pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_operator AS o "
+	"                JOIN pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.opid "
+	"                    FROM pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_class r "
+	"JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+/* v14 is like v15, but lacks stxdinherit on pg_statistic_ext_data */
+const char *export_ext_query_v14 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(dr) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv, "
+	"                    ( "
+	"                        SELECT array_agg(sr ORDER BY sr.staattnum) "
+	"                        FROM ( "
+	"                            SELECT "
+	"                                 s.staattnum, "
+	"                                 s.stanullfrac, "
+	"                                 s.stawidth, "
+	"                                 s.stadistinct, "
+	"                                 s.stakind1, "
+	"                                 s.stakind2, "
+	"                                 s.stakind3, "
+	"                                 s.stakind4, "
+	"                                 s.stakind5, "
+	"                                 s.staop1, "
+	"                                 s.staop2, "
+	"                                 s.staop3, "
+	"                                 s.staop4, "
+	"                                 s.staop5, "
+	"                                 s.stacoll1, "
+	"                                 s.stacoll2, "
+	"                                 s.stacoll3, "
+	"                                 s.stacoll4, "
+	"                                 s.stacoll5, "
+	"                                 s.stanumbers1::text AS stanumbers1, "
+	"                                 s.stanumbers2::text AS stanumbers2, "
+	"                                 s.stanumbers3::text AS stanumbers3, "
+	"                                 s.stanumbers4::text AS stanumbers4, "
+	"                                 s.stanumbers5::text AS stanumbers5, "
+	"                                 s.stavalues1::text AS stavalues1, "
+	"                                 s.stavalues2::text AS stavalues2, "
+	"                                 s.stavalues3::text AS stavalues3, "
+	"                                 s.stavalues4::text AS stavalues4, "
+	"                                 s.stavalues5::text AS stavalues5 "
+	"                            FROM unnest(sd.stxdexpr) AS s "
+	"                            WHERE sd.stxdexpr IS NOT NULL "
+	"                        ) AS sr "
+	"                    ) AS stxdexpr "
+	"                FROM pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) dr "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            select array_agg(tr ORDER BY tr.oid) "
+	"            from ( "
+	"                select "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                from pg_type as t "
+	"                join pg_namespace as n on n.oid = t.typnamespace "
+	"                where t.oid in ( "
+	"                    select a.atttypid "
+	"                    from pg_attribute as a "
+	"                    where a.attrelid = r.oid "
+	"                    and not a.attisdropped "
+	"                    and a.attnum > 0 "
+	"                ) "
+	"            ) as tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_operator AS o "
+	"                JOIN pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.opid "
+	"                    FROM pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_class r "
+	"JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+/* v12-v13 are like v14, but lack stxdexpr on pg_statistic_ext_data */
+const char *export_ext_query_v12 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(r) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv "
+	"                FROM pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) r "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_type AS t "
+	"                JOIN pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_class r "
+	"JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+/*
+ * v10-v11 are like v12, but:
+ *     - MCV is gone
+ *     - remaining stats are stored on pg_statistic_ext
+ *     - pg_statistic_ext_data is gone
+ */
+
+const char *export_ext_query_v10 =
+	"SELECT "
+	"    n.nspname AS schemaname, "
+	"    r.relname AS relname, "
+	"    e.stxname AS ext_stats_name, "
+	"    (current_setting('server_version_num'::text))::integer AS server_version_num, "
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'stxndistinct', e.stxndistinct::text, "
+	"        'stxdependencies', e.stxdependencies::text, "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_type AS t "
+	"                JOIN pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_collation AS c "
+	"                JOIN pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY r.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_class r "
+	"JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_namespace AS n ON n.oid = r.relnamespace "
+	"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+	"AND r.relpersistence = 'p' "
+	"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') ";
+
+
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"echo", no_argument, NULL, 'e'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		echo = false;
+
+	PQExpBufferData sql;
+
+	PGconn	   *conn;
+	int			server_version_num;
+
+	FILE	   *copystream = stdout;
+
+	PGresult   *result;
+
+	ExecStatusType result_status;
+
+	char	   *buf;
+	int			ret;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:eh:p:U:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'e':
+				echo = true;
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, echo, false, true);
+
+	server_version_num = PQserverVersion(conn);
+
+	initPQExpBuffer(&sql);
+
+	appendPQExpBufferStr(&sql, "COPY (");
+
+	if (server_version_num >= 120000)
+		appendPQExpBufferStr(&sql, export_rel_query_v12);
+	else if (server_version_num >= 100000)
+		appendPQExpBufferStr(&sql, export_rel_query_v10);
+	else
+		pg_fatal("exporting statistics from databases prior to version 10 not supported");
+
+	appendPQExpBufferStr(&sql, " UNION ALL ");
+
+	if (server_version_num >= 150000)
+		appendPQExpBufferStr(&sql, export_ext_query_v15);
+	else if (server_version_num >= 140000)
+		appendPQExpBufferStr(&sql, export_ext_query_v14);
+	else if (server_version_num >= 120000)
+		appendPQExpBufferStr(&sql, export_ext_query_v12);
+	else if (server_version_num >= 100000)
+		appendPQExpBufferStr(&sql, export_ext_query_v10);
+	else
+		pg_fatal("exporting statistics from databases prior to version 10 not supported");
+
+	appendPQExpBufferStr(&sql, " ORDER BY 1, 2, 3) TO STDOUT");
+ 
+	/* printf("%s\n", sql.data); */
+	result = PQexec(conn, sql.data);
+	result_status = PQresultStatus(result);
+
+	if (result_status != PGRES_COPY_OUT)
+		pg_fatal("malformed copy command: %s", PQerrorMessage(conn));
+
+	for (;;)
+	{
+		ret = PQgetCopyData(conn, &buf, 0);
+
+		if (ret < 0)
+			break;				/* done or server/connection error */
+
+		if (buf)
+		{
+			if (copystream && fwrite(buf, 1, ret, copystream) != ret)
+				pg_fatal("could not write COPY data: %m");
+			PQfreemem(buf);
+		}
+	}
+
+	if (copystream && fflush(copystream))
+		pg_fatal("could not write COPY data: %m");
+
+	if (ret == -2)
+		pg_fatal("COPY data transfer failed: %s", PQerrorMessage(conn));
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -e, --echo                show the commands being sent to the server\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
diff --git a/src/bin/scripts/pg_import_stats.c b/src/bin/scripts/pg_import_stats.c
new file mode 100644
index 0000000000..96a7252fec
--- /dev/null
+++ b/src/bin/scripts/pg_import_stats.c
@@ -0,0 +1,477 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_import_stats
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_import_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/string_utils.h"
+
+#define COPY_BUF_LEN 8192
+
+static void help(const char *progname);
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"quiet", no_argument, NULL, 'q'},
+		{"dbname", required_argument, NULL, 'd'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		quiet = false;
+
+	PGconn	   *conn;
+
+	FILE	   *copysrc= stdin;
+
+	PGresult   *result;
+
+	int		i;
+	int		numtables;
+	int		numextstats;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "clusterdb", help);
+
+	while ((c = getopt_long(argc, argv, "d:h:p:qU:wW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'q':
+				quiet = true;
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, false, false, true);
+
+	/* open file */
+
+	/* iterate over records */
+
+	/*
+	 * Create a table that can received the COPY-ed file which is a mix
+	 * of relation statistics and extended statistics.
+	 */
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_stats ( "
+		"schemaname text, "
+		"relname text, "
+		"ext_stats_name text, "
+		"server_version_num integer, "
+		"stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	/*
+	 * Create a table just for the relation statistics
+	 */
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_rel_stats ( "
+		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
+		"schemaname text, "
+		"relname text, "
+		"server_version_num integer, "
+		"stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
+
+
+	PQclear(result);
+
+	/*
+	 * Create a table just for extended statistics
+	 */
+	result = PQexec(conn,
+		"CREATE TEMPORARY TABLE import_ext_stats ( "
+		"id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, "
+		"schemaname text, "
+		"relname text, "
+		"ext_stats_name text, "
+		"server_version_num integer, "
+		"stats jsonb )");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("could not create temporary table: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	/*
+	 * Copy input data into combined table.
+	 */
+	result = PQexec(conn,
+		"COPY import_stats FROM STDIN");
+
+	if (PQresultStatus(result) != PGRES_COPY_IN)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	for (;;)
+	{
+		char copybuf[COPY_BUF_LEN];
+
+		int numread = fread(copybuf, 1, COPY_BUF_LEN, copysrc);
+
+		if (ferror(copysrc))
+			pg_fatal("error reading from source");
+
+		if (numread == 0)
+			break;
+
+		if (PQputCopyData(conn, copybuf, numread) == -1)
+			pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	}
+
+	if (PQputCopyEnd(conn, NULL) == -1)
+		pg_fatal("eror during copy: %s", PQerrorMessage(conn));
+	fclose(copysrc);
+
+	result = PQgetResult(conn);
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("error copying data to import_stats: %s", PQerrorMessage(conn));
+
+	PQclear(result);
+
+	/*
+	 * Insert rel stats into their own table with numbering.
+	 */
+	result = PQexec(conn,
+		"INSERT INTO import_rel_stats(schemaname, relname, server_version_num, "
+		"stats) "
+		"SELECT schemaname, relname, server_version_num, stats "
+		"FROM import_stats "
+		"WHERE ext_stats_name IS NULL ");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("relation stats insert error: %s", PQerrorMessage(conn));
+
+	numtables = atol(PQcmdTuples(result));
+
+	PQclear(result);
+
+	/*
+	 * Insert extended stats into their own table with numbering.
+	 */
+	result = PQexec(conn,
+		"INSERT INTO import_ext_stats(schemaname, relname, ext_stats_name, "
+		"server_version_num, stats) "
+		"SELECT schemaname, relname, ext_stats_name, server_version_num, "
+		"stats "
+		"FROM import_stats "
+		"WHERE ext_stats_name IS NOT NULL ");
+
+	if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		pg_fatal("relation stats insert error: %s", PQerrorMessage(conn));
+
+	numextstats = atol(PQcmdTuples(result));
+
+	PQclear(result);
+
+	if (numtables > 0)
+	{
+
+		result = PQprepare(conn, "import_rel",
+			"SELECT pg_import_rel_stats(c.oid, s.stats, true, true) AS import_result "
+			"FROM import_rel_stats AS s "
+			"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+			"JOIN pg_class AS c ON c.relnamespace = n.oid "
+			"                   AND c.relname = s.relname "
+			"WHERE s.id = $1::bigint ",
+			1, NULL);
+
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+		PQclear(result);
+
+		if (!quiet)
+		{
+			result = PQprepare(conn, "echo_rel",
+				"SELECT s.schemaname, s.relname "
+				"FROM import_rel_stats AS s "
+				"WHERE s.id = $1::bigint ",
+				1, NULL);
+
+			if (PQresultStatus(result) != PGRES_COMMAND_OK)
+				pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+			PQclear(result);
+		}
+
+		for (i = 1; i <= numtables; i++)
+		{
+			char	istr[32];
+			char   *schema = NULL;
+			char   *table = NULL;
+
+			const char *const values[] = {istr};
+
+			snprintf(istr, 32, "%d", i);
+
+			if (!quiet)
+			{
+				result = PQexecPrepared(conn, "echo_rel", 1, values, NULL, NULL, 0);
+				schema = pg_strdup(PQgetvalue(result, 0, 0));
+				table = pg_strdup(PQgetvalue(result, 0, 1));
+			}
+
+			PQclear(result);
+
+			result = PQexecPrepared(conn, "import_rel", 1, values, NULL, NULL, 0);
+
+			if (quiet)
+			{
+				PQclear(result);
+				continue;
+			}
+
+			if (PQresultStatus(result) == PGRES_TUPLES_OK)
+			{
+				int 	rows = PQntuples(result);
+
+				if (rows == 1)
+				{
+					char   *retval = PQgetvalue(result, 0, 0);
+					if (*retval == 't')
+						printf("%s.%s: imported\n", schema, table);
+					else
+						printf("%s.%s: failed\n", schema, table);
+				}
+				else if (rows == 0)
+					printf("%s.%s: not found\n", schema, table);
+				else
+					pg_fatal("import function must return 0 or 1 rows");
+			}
+			else
+				printf("%s.%s: error: %s\n", schema, table, PQerrorMessage(conn));
+
+			if (schema != NULL)
+				pfree(schema);
+
+			if (table != NULL)
+				pfree(table);
+
+			PQclear(result);
+		}
+	}
+
+	if (numextstats > 0)
+	{
+
+	result = PQprepare(conn, "import_ext",
+		"SELECT pg_import_ext_stats(e.oid, s.stats, true, true) AS import_result "
+		"FROM import_ext_stats AS s "
+		"JOIN pg_namespace AS n ON n.nspname = s.schemaname "
+		"JOIN pg_class AS c ON c.relnamespace = n.oid "
+		"                   AND c.relname = s.relname "
+		"JOIN pg_statistic_ext AS e ON e.stxrelid = c.oid "
+		"                   AND e.stxname = s.ext_stats_name "
+		"WHERE s.id = $1::bigint "
+		"AND false ", /* remove when we enable extended stats */
+		1, NULL);
+
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+			pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+		PQclear(result);
+
+		if (!quiet)
+		{
+			result = PQprepare(conn, "echo_ext",
+				"SELECT s.schemaname, s.relname, s.ext_stats_name "
+				"FROM import_ext_stats AS s "
+				"WHERE s.id = $1::bigint ",
+				1, NULL);
+
+			if (PQresultStatus(result) != PGRES_COMMAND_OK)
+				pg_fatal("error in PREPARE: %s", PQerrorMessage(conn));
+
+			PQclear(result);
+		}
+
+		for (i = 1; i <= numextstats; i++)
+		{
+			char	istr[32];
+			char   *schema = NULL;
+			char   *table = NULL;
+			char   *stat = NULL;
+
+			const char *const values[] = {istr};
+
+			snprintf(istr, 32, "%d", i);
+
+			if (!quiet)
+			{
+				result = PQexecPrepared(conn, "echo_ext", 1, values, NULL, NULL, 0);
+				schema = pg_strdup(PQgetvalue(result, 0, 0));
+				table = pg_strdup(PQgetvalue(result, 0, 1));
+				stat = pg_strdup(PQgetvalue(result, 0, 2));
+			}
+
+			PQclear(result);
+
+			result = PQexecPrepared(conn, "import_ext", 1, values, NULL, NULL, 0);
+
+			if (quiet)
+			{
+				PQclear(result);
+				continue;
+			}
+
+			if (PQresultStatus(result) == PGRES_TUPLES_OK)
+			{
+				int 	rows = PQntuples(result);
+
+				if (rows == 1)
+				{
+					char   *retval = PQgetvalue(result, 0, 0);
+					if (*retval == 't')
+						printf("%s on %s.%s: imported\n", stat, schema, table);
+					else
+						printf("%s on %s.%s: failed\n", stat, schema, table);
+				}
+				else if (rows == 0)
+					printf("%s on %s.%s: not found\n", stat, schema, table);
+				else
+					pg_fatal("import function must return 0 or 1 rows");
+			}
+			else
+				printf("%s on %s.%s: error: %s\n", stat, schema, table, PQerrorMessage(conn));
+
+			if (schema != NULL)
+				pfree(schema);
+
+			if (table != NULL)
+				pfree(table);
+
+			if (stat != NULL)
+				pfree(stat);
+
+			PQclear(result);
+		}
+	}
+
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s clusters all previously clustered tables in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to cluster\n"));
+	printf(_("  -q, --quiet               don't write any messages\n"));
+	printf(_("  -t, --table=TABLE         cluster specific table(s) only\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nRead the description of the SQL command CLUSTER for details.\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
-- 
2.43.0

From 9adcc9735069edc14af05b28088725594e912c84 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 15 Feb 2024 03:11:40 -0500
Subject: [PATCH v5 1/2] Create pg_import_rel_stats.

The function pg_import_rel_stats imports pg_class rowcount,
pagecount, and pg_statistic data for a given relation.

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a jsonb parameter which contains the generated
statistics for one relaton, the format of which varies by the version
of the server that exported it. The function takes that version
int account when processing the input json into pg_statistic rows.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

While the statistics are applied transactionally, the changes to
pg_class (reltuples and relpages) are not. This decision was made
to avoid bloat of pg_class and is in line with the behavior of VACUUM.

Currently the function supports two boolean flags for checking the
validity of the imported data. The flag validate initiates a battery
of validation tests to ensure that all sub-objects (types, operators,
collatons, attributes, statistics) have no duplicate values. The flag
require_match_oids verifies the oids resolved in the new statistics rows
match the oids specified in the json. Setting this flag makes sense
during a binary upgrade, but not a restore.

This function also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |    6 +-
 src/include/statistics/statistics.h           |    2 +
 src/include/statistics/statistics_internal.h  |   28 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1331 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  530 +++++++
 src/test/regress/parallel_schedule            |    2 +-
 src/test/regress/sql/stats_export_import.sql  |  499 ++++++
 doc/src/sgml/func.sgml                        |   65 +
 10 files changed, 2464 insertions(+), 3 deletions(-)
 create mode 100644 src/include/statistics/statistics_internal.h
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 9c120fc2b7..0e48c08566 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -8825,7 +8825,11 @@
 { oid => '3813', descr => 'generate XML text node',
   proname => 'xmltext', proisstrict => 't', prorettype => 'xml',
   proargtypes => 'text', prosrc => 'xmltext' },
-
+{ oid => '3814',
+  descr => 'statistics: import to relation',
+  proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_rel_stats' },
 { oid => '2923', descr => 'map table contents to XML',
   proname => 'table_to_xml', procost => '100', provolatile => 's',
   proparallel => 'r', prorettype => 'xml',
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..0c3867f918 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_import_rel_stats(PG_FUNCTION_ARGS);
+
 #endif							/* STATISTICS_H */
diff --git a/src/include/statistics/statistics_internal.h b/src/include/statistics/statistics_internal.h
new file mode 100644
index 0000000000..e61a64d8b7
--- /dev/null
+++ b/src/include/statistics/statistics_internal.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics_internal.h
+ *	  Extended statistics and selectivity estimation functions.
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/statistics/statistics_internal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef STATISTICS_INTERNAL_H
+#define STATISTICS_INTERNAL_H
+
+#include "nodes/pathnodes.h"
+
+extern void validate_no_duplicates(Datum document, bool document_null,
+								   const char *sql, const char *docname,
+								   const char *colname);
+
+extern void validate_exported_types(Datum types, bool types_null);
+extern void validate_exported_collations(Datum collations, bool collations_null);
+extern void validate_exported_operators(Datum operators, bool operators_null);
+extern void validate_exported_attributes(Datum attributes, bool attributes_null);
+extern void validate_exported_statistics(Datum statistics, bool statistics_null);
+
+#endif							/* STATISTICS_INTERNAL_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..25ae54d4e8
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1331 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics.c
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "executor/spi.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "statistics/statistics_internal.h"
+#include "utils/builtins.h"
+#include "utils/rel.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Struct to capture only the infomration we need from
+ * get_attrinfo
+ */
+typedef struct {
+	Oid		typid;
+	int32	typmod;
+	Oid		collid;
+	Oid 	eqopr;
+	Oid 	ltopr;
+	Oid		basetypid;
+	Oid 	baseeqopr;
+	Oid 	baseltopr;
+} AttrInfo;
+
+
+/*
+ * Generate AttrInfo entries for each attribute in the relation.
+ * This data is a small subset of what VacAttrStats collects,
+ * and we leverage VacAttrStats to stay compatible with what
+ * do_analyze() does.
+ */
+static AttrInfo *
+get_attrinfo(Relation rel)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	bool		has_index_exprs = false;
+	ListCell   *indexpr_item = NULL;
+	AttrInfo   *res = palloc0(natts * sizeof(AttrInfo));
+	int			i;
+
+	/*
+	 * If this relation is an index and that index has expressions in
+	 * it, then we will need to keep the list of remaining expressions
+	 * aligned with the attributes as we iterate over them, whether or
+	 * not those attributes have statistics to import.
+	*/
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+				|| (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+			&& (rel->rd_indexprs != NIL))
+	{
+		has_index_exprs = true;
+		indexpr_item = list_head(rel->rd_indexprs);
+	}
+
+	for (i = 0; i < natts; i++)
+	{
+		Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);
+
+		/*
+		 * If this this attribute is an expression, pop an expression off
+		 * of the list. We need to do this even if the attribute is
+		 * dropped to pop a potential expression off the list.
+		 */
+		if (has_index_exprs && (rel->rd_index->indkey.values[i] == 0))
+		{
+			Node *index_expr = NULL;
+
+			if (indexpr_item == NULL)   /* shouldn't happen */
+				elog(ERROR, "too few entries in indexprs list");
+
+			index_expr = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+			res[i].typid = exprType(index_expr);
+			res[i].typmod = exprTypmod(index_expr);
+
+			/*
+			 * If a collation has been specified for the index column, use that in
+			 * preference to anything else; but if not, fall back to whatever we
+			 * can get from the expression.
+			 */
+			if (OidIsValid(attr->attcollation))
+				res[i].collid = attr->attcollation;
+			else
+				res[i].collid = exprCollation(index_expr);
+		}
+		else
+		{
+			res[i].typid = attr->atttypid;
+			res[i].typmod = attr->atttypmod;
+			res[i].collid = attr->attcollation;
+		}
+
+		if (attr->attisdropped)
+			continue;
+
+		get_sort_group_operators(res[i].typid,
+								 false, false, false,
+								 &res[i].ltopr, &res[i].eqopr, NULL,
+								 NULL);
+
+		res[i].basetypid = get_base_element_type(res[i].typid);
+		if (res[i].basetypid == InvalidOid)
+		{
+			/* type is its own base type */
+			res[i].basetypid = res[i].typid;
+			res[i].baseltopr = res[i].ltopr;
+			res[i].baseeqopr = res[i].eqopr;
+		}
+		else
+			get_sort_group_operators(res[i].basetypid,
+									 false, false, false,
+									 &res[i].baseltopr, &res[i].baseeqopr,
+									 NULL, NULL);
+	}
+	return res;
+}
+
+/*
+ * Delete all pg_statistic entries for a relation + inheritance type
+ */
+static void
+remove_pg_statistics(Relation rel, Relation sd, bool inh)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	int			attnum;
+
+	for (attnum = 1; attnum <= natts; attnum++)
+	{
+		HeapTuple tup = SearchSysCache3(STATRELATTINH,
+							ObjectIdGetDatum(RelationGetRelid(rel)),
+							Int16GetDatum(attnum),
+							BoolGetDatum(inh));
+
+		if (HeapTupleIsValid(tup))
+		{
+			CatalogTupleDelete(sd, &tup->t_self);
+
+			ReleaseSysCache(tup);
+		}
+	}
+}
+
+#define NULLARG(x) ((x) ? 'n' : ' ')
+
+/*
+ * Find any duplicate values in a jsonb object casted via SPI SQL
+ * into a single-key table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_no_duplicates(Datum document, bool document_null,
+					   const char *sql, const char *docname,
+					   const char *colname)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { document };
+	char	argnulls[1] = { NULLARG(document_null) };
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		char *s = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s",
+						docname, colname, (s) ? s : "NULL")));
+	}
+}
+
+/*
+ * Ensure that the "types" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_types(Datum types, bool types_null)
+{
+	const char *sql =
+		"SELECT et.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS et(oid oid, typname text, nspname text) "
+		"GROUP BY et.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(types, types_null, sql, "types", "oid");
+}
+
+/*
+ * Ensure that the "collations" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_collations(Datum collations, bool collations_null)
+{
+	const char* sql =
+		"SELECT ec.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ec(oid oid, collname text, nspname text) "
+		"GROUP BY ec.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(collations, collations_null, sql, "collations", "oid");
+}
+
+/*
+ * Ensure that the "operators" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_operators(Datum operators, bool operators_null)
+{
+	const char* sql =
+		"SELECT eo.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS eo(oid oid, oprname text, nspname text) "
+		"GROUP BY eo.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(operators, operators_null, sql, "operators", "oid");
+}
+
+/*
+ * Ensure that the "attributes" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate attnum
+ * values exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_attributes(Datum attributes, bool attributes_null)
+{
+	const char* sql =
+		"SELECT ea.attnum "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ea(attnum int2, attname text, atttypid oid, "
+		"           attcollation oid) "
+		"GROUP BY ea.attnum "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(attributes, attributes_null, sql, "attributes", "attnum");
+}
+
+/*
+ * Ensure that the "statistics" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate combinations
+ * of (staattnum, stainherit) exist within the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_statistics(Datum statistics, bool statistics_null)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { statistics };
+	char	argnulls[1] = { NULLARG(statistics_null) };
+
+	const char *sql =
+		"SELECT s.staattnum, s.stainherit "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"GROUP BY s.staattnum, s.stainherit "
+		"HAVING COUNT(*) > 1 ";
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (tuptable->numvals > 0)
+	{
+		char *s1 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		char *s2 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 2);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s, %s = %s",
+						"statistics", "staattnum", (s1) ? s1 : "NULL",
+						"stainherit", (s2) ? s2 : "NULL")));
+	}
+}
+
+
+/*
+ * Transactionally import statistics for a given relation
+ * into pg_statistic.
+ *
+ * The jsonb datums are in the same order:
+ *     types, collations, operators, attributes, statistics
+ *
+ * The statistics import query does not vary by server version.
+ * However, the stacollN columns will always be NULL for versions prior
+ * to v12.
+ *
+ * The query as currently written is clearly overboard, and for now serves
+ * to show what is possible in terms of comparing the exported statistics
+ * to the existing local schema. Once we have determined what types of
+ * checks are worthwhile, we can trim out unnecessary joins and columns.
+ *
+ * Analytic columns columns like dup_count serve to check the consistency
+ * and correctness of the exported data.
+ *
+ * The return value is an array of HeapTuples.
+ * The parameter ntuples is set to the number of HeapTuples returned.
+ */
+
+static HeapTuple *
+import_pg_statistics(Relation rel, Relation sd, int server_version_num,
+					 Datum types_datum, bool types_null,
+					 Datum collations_datum, bool collations_null,
+					 Datum operators_datum, bool operators_null,
+					 Datum attributes_datum, bool attributes_null,
+					 Datum statistics_datum, bool statistics_null,
+					 bool require_match_oids, int *ntuples)
+{
+
+#define PGS_NARGS 6
+
+	Oid			argtypes[PGS_NARGS] = {
+					JSONBOID, JSONBOID, JSONBOID, JSONBOID, JSONBOID, OIDOID };
+	Datum		args[PGS_NARGS] = {
+					types_datum, collations_datum, operators_datum,
+					attributes_datum, statistics_datum,
+					ObjectIdGetDatum(RelationGetRelid(rel)) };
+	char		argnulls[PGS_NARGS] = {
+					NULLARG(types_null), NULLARG(collations_null),
+					NULLARG(operators_null), NULLARG(attributes_null),
+					NULLARG(statistics_null), NULLARG(false) };
+
+	/*
+	 * This query is currently in kitchen-sink mode, and it can be trimmed down
+	 * to eliminate any columns not needed for output or validation once
+	 * all requirements are settled.
+	 */
+	const char *sql =
+		"WITH exported_types AS ( "
+		"    SELECT et.* "
+		"    FROM jsonb_to_recordset($1) "
+		"        AS et(oid oid, typname text, nspname text) "
+		"), "
+		"exported_collations AS ( "
+		"    SELECT ec.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS ec(oid oid, collname text, nspname text) "
+		"), "
+		"exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($3) "
+		"        AS eo(oid oid, oprname text, nspname text) "
+		"), "
+		"exported_attributes AS ( "
+		"    SELECT ea.* "
+		"    FROM jsonb_to_recordset($4) "
+		"        AS ea(attnum int2, attname text, atttypid oid, "
+		"              attcollation oid) "
+		"), "
+		"exported_statistics AS ( "
+		"    SELECT s.* "
+		"    FROM jsonb_to_recordset($5) "
+		"        AS s(staattnum integer, "
+		"             stainherit boolean, "
+		"             stanullfrac float4, "
+		"             stawidth integer, "
+		"             stadistinct float4, "
+		"             stakind1 int2, "
+		"             stakind2 int2, "
+		"             stakind3 int2, "
+		"             stakind4 int2, "
+		"             stakind5 int2, "
+		"             staop1 oid, "
+		"             staop2 oid, "
+		"             staop3 oid, "
+		"             staop4 oid, "
+		"             staop5 oid, "
+		"             stacoll1 oid, "
+		"             stacoll2 oid, "
+		"             stacoll3 oid, "
+		"             stacoll4 oid, "
+		"             stacoll5 oid, "
+		"             stanumbers1 float4[], "
+		"             stanumbers2 float4[], "
+		"             stanumbers3 float4[], "
+		"             stanumbers4 float4[], "
+		"             stanumbers5 float4[], "
+		"             stavalues1 text, "
+		"             stavalues2 text, "
+		"             stavalues3 text, "
+		"             stavalues4 text, "
+		"             stavalues5 text) "
+		") "
+		"SELECT pga.attnum, pga.attname, pga.atttypid, pga.atttypmod, "
+		"       pga.attcollation, pgat.typname, pgac.collname, "
+		"       ea.attnum AS exp_attnum, ea.atttypid AS exp_atttypid, "
+		"       ea.attcollation AS exp_attcollation, "
+		"       et.typname AS exp_typname, et.nspname AS exp_typschema, "
+		"       ec.collname AS exp_collname, ec.nspname AS exp_collschema, "
+		"       es.stainherit, es.stanullfrac, es.stawidth, es.stadistinct, "
+		"       es.stakind1, es.stakind2, es.stakind3, es.stakind4, "
+		"       es.stakind5, "
+		"       es.staop1 AS exp_staop1, es.staop2 AS exp_staop2, "
+		"       es.staop3 AS exp_staop3, es.staop4 AS exp_staop4, "
+		"       es.staop5 AS exp_staop5, "
+		"       es.stacoll1 AS exp_staop1, es.stacoll2 AS exp_staop2, "
+		"       es.stacoll3 AS exp_staop3, es.stacoll4 AS exp_staop4, "
+		"       es.stacoll5 AS exp_staop5, "
+		"       es.stanumbers1, es.stanumbers2, es.stanumbers3, "
+		"       es.stanumbers4, es.stanumbers5, "
+		"       es.stavalues1, es.stavalues2, es.stavalues3, es.stavalues4, "
+		"       es.stavalues5, "
+		"       eo1.nspname AS exp_oprschema1, "
+		"       eo2.nspname AS exp_oprschema2, "
+		"       eo3.nspname AS exp_oprschema3, "
+		"       eo4.nspname AS exp_oprschema4, "
+		"       eo5.nspname AS exp_oprschema5, "
+		"       eo1.oprname AS exp_oprname1, "
+		"       eo2.oprname AS exp_oprname2, "
+		"       eo3.oprname AS exp_oprname3, "
+		"       eo4.oprname AS exp_oprname4, "
+		"       eo5.oprname AS exp_oprname5, "
+		"       coalesce(io1.oid, 0) AS staop1, "
+		"       coalesce(io2.oid, 0) AS staop2, "
+		"       coalesce(io3.oid, 0) AS staop3, "
+		"       coalesce(io4.oid, 0) AS staop4, "
+		"       coalesce(io5.oid, 0) AS staop5, "
+		"       ec1.nspname AS exp_collschema1, "
+		"       ec2.nspname AS exp_collschema2, "
+		"       ec3.nspname AS exp_collschema3, "
+		"       ec4.nspname AS exp_collschema4, "
+		"       ec5.nspname AS exp_collschema5, "
+		"       ec1.collname AS exp_collname1, "
+		"       ec2.collname AS exp_collname2, "
+		"       ec3.collname AS exp_collname3, "
+		"       ec4.collname AS exp_collname4, "
+		"       ec5.collname AS exp_collname5, "
+		"       coalesce(ic1.oid, 0) AS stacoll1, "
+		"       coalesce(ic2.oid, 0) AS stacoll2, "
+		"       coalesce(ic3.oid, 0) AS stacoll3, "
+		"       coalesce(ic4.oid, 0) AS stacoll4, "
+		"       coalesce(ic5.oid, 0) AS stacoll5, "
+		"       (pga.attname IS DISTINCT FROM ea.attname) AS attname_miss, "
+		"       (ea.attnum IS DISTINCT FROM es.staattnum) AS staattnum_miss, "
+		"       COUNT(*) OVER (PARTITION BY pga.attnum, "
+		"                                   es.stainherit) AS dup_count "
+		"FROM pg_attribute AS pga "
+		"JOIN pg_type AS pgat ON pgat.oid = pga.atttypid "
+		"LEFT JOIN pg_collation AS pgac ON pgac.oid = pga.attcollation "
+		"LEFT JOIN exported_attributes AS ea ON ea.attname = pga.attname "
+		"LEFT JOIN exported_statistics AS es ON es.staattnum = ea.attnum "
+		"LEFT JOIN exported_types AS et ON et.oid = ea.atttypid "
+		"LEFT JOIN exported_collations AS ec ON ec.oid = ea.attcollation "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = es.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = es.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = es.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = es.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = es.staop5 "
+		"LEFT JOIN exported_collations AS ec1 ON ec1.oid = es.stacoll1 "
+		"LEFT JOIN exported_collations AS ec2 ON ec2.oid = es.stacoll2 "
+		"LEFT JOIN exported_collations AS ec3 ON ec3.oid = es.stacoll3 "
+		"LEFT JOIN exported_collations AS ec4 ON ec4.oid = es.stacoll4 "
+		"LEFT JOIN exported_collations AS ec5 ON ec5.oid = es.stacoll5 "
+		"LEFT JOIN pg_namespace AS ion1 ON ion1.nspname = eo1.nspname "
+		"LEFT JOIN pg_namespace AS ion2 ON ion2.nspname = eo2.nspname "
+		"LEFT JOIN pg_namespace AS ion3 ON ion3.nspname = eo3.nspname "
+		"LEFT JOIN pg_namespace AS ion4 ON ion4.nspname = eo4.nspname "
+		"LEFT JOIN pg_namespace AS ion5 ON ion5.nspname = eo5.nspname "
+		"LEFT JOIN pg_namespace AS icn1 ON icn1.nspname = ec1.nspname "
+		"LEFT JOIN pg_namespace AS icn2 ON icn2.nspname = ec2.nspname "
+		"LEFT JOIN pg_namespace AS icn3 ON icn3.nspname = ec3.nspname "
+		"LEFT JOIN pg_namespace AS icn4 ON icn4.nspname = ec4.nspname "
+		"LEFT JOIN pg_namespace AS icn5 ON icn5.nspname = ec5.nspname "
+		"LEFT JOIN pg_operator AS io1 ON io1.oprnamespace = ion1.oid "
+		"    AND io1.oprname = eo1.oprname "
+		"    AND io1.oprleft = pga.atttypid "
+		"    AND io1.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io2 ON io2.oprnamespace = ion2.oid "
+		"    AND io2.oprname = eo2.oprname "
+		"    AND io2.oprleft = pga.atttypid "
+		"    AND io2.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io3 ON io3.oprnamespace = ion3.oid "
+		"    AND io3.oprname = eo3.oprname "
+		"    AND io3.oprleft = pga.atttypid "
+		"    AND io3.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io4 ON io4.oprnamespace = ion4.oid "
+		"    AND io4.oprname = eo4.oprname "
+		"    AND io4.oprleft = pga.atttypid "
+		"    AND io4.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io5 ON io5.oprnamespace = ion5.oid "
+		"    AND io5.oprname = eo5.oprname "
+		"    AND io5.oprleft = pga.atttypid "
+		"    AND io5.oprright = pga.atttypid "
+		"LEFT JOIN pg_collation as ic1 "
+		"   ON ic1.collnamespace = icn1.oid AND ic1.collname = ec1.collname "
+		"LEFT JOIN pg_collation as ic2 "
+		"   ON ic2.collnamespace = icn2.oid AND ic2.collname = ec2.collname "
+		"LEFT JOIN pg_collation as ic3 "
+		"   ON ic3.collnamespace = icn3.oid AND ic3.collname = ec3.collname "
+		"LEFT JOIN pg_collation as ic4 "
+		"   ON ic4.collnamespace = icn4.oid AND ic4.collname = ec4.collname "
+		"LEFT JOIN pg_collation as ic5 "
+		"   ON ic5.collnamespace = icn5.oid AND ic5.collname = ec5.collname "
+		"WHERE pga.attrelid = $6 "
+		"AND pga.attnum > 0 "
+		"ORDER BY pga.attnum, coalesce(es.stainherit, false)";
+
+	/*
+	 * Columns with names containing _EXP_ are values that come from exported
+	 * json data and therefore should not be directly imported into
+	 * pg_statistic. Those values were joined to current catalog values to
+	 * derive the proper value to import, and the column is exposed mostly
+	 * for validation purposes.
+	 */
+	enum
+	{
+		PGS_ATTNUM = 0,
+		PGS_ATTNAME,
+		PGS_ATTTYPID,
+		PGS_ATTTYPMOD,
+		PGS_ATTCOLLATION,
+		PGS_TYPNAME,
+		PGS_COLLNAME,
+		PGS_EXP_ATTNUM,
+		PGS_EXP_ATTTYPID,
+		PGS_EXP_ATTCOLLATION,
+		PGS_EXP_TYPNAME,
+		PGS_EXP_TYPSCHEMA,
+		PGS_EXP_COLLNAME,
+		PGS_EXP_COLLSCHEMA,
+		PGS_STAINHERIT,
+		PGS_STANULLFRAC,
+		PGS_STAWIDTH,
+		PGS_STADISTINCT,
+		PGS_STAKIND1,
+		PGS_STAKIND2,
+		PGS_STAKIND3,
+		PGS_STAKIND4,
+		PGS_STAKIND5,
+		PGS_EXP_STAOP1,
+		PGS_EXP_STAOP2,
+		PGS_EXP_STAOP3,
+		PGS_EXP_STAOP4,
+		PGS_EXP_STAOP5,
+		PGS_EXP_STACOLL1,
+		PGS_EXP_STACOLL2,
+		PGS_EXP_STACOLL3,
+		PGS_EXP_STACOLL4,
+		PGS_EXP_STACOLL5,
+		PGS_STANUMBERS1,
+		PGS_STANUMBERS2,
+		PGS_STANUMBERS3,
+		PGS_STANUMBERS4,
+		PGS_STANUMBERS5,
+		PGS_STAVALUES1,
+		PGS_STAVALUES2,
+		PGS_STAVALUES3,
+		PGS_STAVALUES4,
+		PGS_STAVALUES5,
+		PGS_EXP_OPRSCHEMA1,
+		PGS_EXP_OPRSCHEMA2,
+		PGS_EXP_OPRSCHEMA3,
+		PGS_EXP_OPRSCHEMA4,
+		PGS_EXP_OPRSCHEMA5,
+		PGS_EXP_OPRNAME1,
+		PGS_EXP_OPRNAME2,
+		PGS_EXP_OPRNAME3,
+		PGS_EXP_OPRNAME4,
+		PGS_EXP_OPRNAME5,
+		PGS_STAOP1,
+		PGS_STAOP2,
+		PGS_STAOP3,
+		PGS_STAOP4,
+		PGS_STAOP5,
+		PGS_EXP_COLLSCHEMA1,
+		PGS_EXP_COLLSCHEMA2,
+		PGS_EXP_COLLSCHEMA3,
+		PGS_EXP_COLLSCHEMA4,
+		PGS_EXP_COLLSCHEMA5,
+		PGS_EXP_COLLNAME1,
+		PGS_EXP_COLLNAME2,
+		PGS_EXP_COLLNAME3,
+		PGS_EXP_COLLNAME4,
+		PGS_EXP_COLLNAME5,
+		PGS_STACOLL1,
+		PGS_STACOLL2,
+		PGS_STACOLL3,
+		PGS_STACOLL4,
+		PGS_STACOLL5,
+		PGS_ATTNAME_MISS,
+		PGS_STAATTNUM_MISS,
+		PGS_DUP_COUNT,
+		NUM_PGS_COLS
+	};
+
+	AttrInfo	*relattrinfo = get_attrinfo(rel);
+	AttrInfo	*attrinfo;
+
+	int		ret;
+	int		i;
+	int		tupctr = 0;
+
+	SPITupleTable  *tuptable;
+	HeapTuple	   *rettuples;
+
+	ret = SPI_execute_with_args(sql, PGS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	rettuples = palloc0(sizeof(HeapTuple) * tuptable->numvals);
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum		pgs_datums[NUM_PGS_COLS];
+		bool		pgs_nulls[NUM_PGS_COLS];
+		bool		skip = false;
+
+		Datum		values[Natts_pg_statistic] = { 0 };
+		bool		nulls[Natts_pg_statistic] = { false };
+
+		int			dup_count;
+		AttrNumber	attnum;
+		char	   *attname;
+		bool		stainherit;
+		char	   *inhstr;
+		AttrNumber	exported_attnum;
+		FmgrInfo	finfo;
+		int			k;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, pgs_datums,
+						  pgs_nulls);
+
+		/*
+		 * Check all the columns that cannot plausibly be null regardless of
+		 * json data quality
+		 */
+		Assert(!pgs_nulls[PGS_ATTNUM]);
+		Assert(!pgs_nulls[PGS_ATTNAME]);
+		Assert(!pgs_nulls[PGS_ATTTYPID]);
+		Assert(!pgs_nulls[PGS_ATTTYPMOD]);
+		Assert(!pgs_nulls[PGS_ATTCOLLATION]);
+		Assert(!pgs_nulls[PGS_TYPNAME]);
+		Assert(!pgs_nulls[PGS_DUP_COUNT]);
+		Assert(!pgs_nulls[PGS_ATTNAME_MISS]);
+		Assert(!pgs_nulls[PGS_STAATTNUM_MISS]);
+
+		attnum = DatumGetInt16(pgs_datums[PGS_ATTNUM]);
+		attname = NameStr(*(DatumGetName(pgs_datums[PGS_ATTNAME])));
+		attrinfo = &relattrinfo[attnum - 1];
+
+		fmgr_info(F_ARRAY_IN, &finfo);
+
+		if (pgs_nulls[PGS_STAINHERIT])
+		{
+			stainherit = false;
+			inhstr = "NULL";
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAINHERIT]))
+		{
+			stainherit = true;
+			inhstr = "true";
+		}
+		else
+		{
+			stainherit = false;
+			inhstr = "false";
+		}
+
+		/*
+		 * Any duplicates would be a cache collision and a sign that the
+		 * import json is broken.
+		 */
+		dup_count = DatumGetInt32(pgs_datums[PGS_DUP_COUNT]);
+		if (dup_count != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Attribute duplicate count %d on attnum %d attname %s stainherit %s",
+							dup_count, attnum, attname, stainherit ? "t" : "f")));
+		else if (DatumGetBool(pgs_datums[PGS_ATTNAME_MISS]))
+		{
+			/* Do not generate a tuple */
+			skip = true;
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported attribute with name \"%s\" found.", attname)));
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAATTNUM_MISS]))
+		{
+			/* Do not generate a tuple */
+			skip = true;
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported statistic found for exported attribute \"%s\" found.",
+								attname)));
+		}
+
+		/* if we are going to skip this row, clean up first */
+		if (skip)
+		{
+			pfree(attname);
+			continue;
+		}
+
+		exported_attnum = DatumGetInt16(pgs_datums[PGS_EXP_ATTNUM]);
+
+		if (require_match_oids)
+		{
+			Oid	export_typoid = DatumGetObjectId(pgs_datums[PGS_EXP_ATTTYPID]);
+			Oid	catalog_typoid = DatumGetObjectId(pgs_datums[PGS_ATTTYPID]);
+
+			if (export_typoid != catalog_typoid)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d expects typoid %u but typoid %u imported",
+								attnum, catalog_typoid, export_typoid)));
+		}
+
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
+		values[Anum_pg_statistic_staattnum - 1] = pgs_datums[PGS_ATTNUM];
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(stainherit);
+
+		/*
+		 * Any nulls here will fail the when it is written to pg_statistic
+		 * but that error message is as good as any we could create.
+		 */
+		if (pgs_nulls[PGS_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stanullfrac")));
+
+		if (pgs_nulls[PGS_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stawidth")));
+
+		if (pgs_nulls[PGS_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = pgs_datums[PGS_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = pgs_datums[PGS_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = pgs_datums[PGS_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind;
+			Oid		op;
+
+			/*
+			 * stakindN
+			 *
+			 * We can't match order of stakinds from VacAttrStats because which
+			 * entries appear varies by the data in the table.
+			 *
+			 * The stakindN values assigned during ANALYZE will vary by the
+			 * amount and quality of the data sampled. As such, there is no
+			 * fixed set of kinds to match against for any one slot.
+			 *
+			 * Any NULL stakindN values will cause the row to fail.
+			 *
+			 */
+			if (pgs_nulls[PGS_STAKIND1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stakind", k+1)));
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = pgs_datums[PGS_STAKIND1 + k];
+			kind = DatumGetInt16(pgs_datums[PGS_STAKIND1 + k]);
+
+			/*
+			 * staopN
+			 *
+			 * We cannot resolve the exported operator back to a local Oid because
+			 * that cannot be looked up directly in the catalog, so we have to
+			 * instead look at the exported operator name, choose the op from
+			 * the typecache, and then if we're requiring matching oids we can
+			 * compare that to the exported oid.
+			 *
+			 */
+			/* Possibly validate operator must be OidIsValid when stakindN <> 0 */
+			if (pgs_nulls[PGS_EXP_OPRNAME1 + k])
+				op = InvalidOid;
+			else
+			{
+				char   *exp_oprname;
+
+				exp_oprname = TextDatumGetCString(pgs_datums[PGS_EXP_OPRNAME1 + k]);
+				if (strcmp(exp_oprname, "=") == 0)
+				{
+					/*
+					 * MCELEM stat arrays are of the same type as the
+					 * array base element type and are eqopr
+					 */
+					if ((kind == STATISTIC_KIND_MCELEM) ||
+						(kind == STATISTIC_KIND_DECHIST))
+						op = attrinfo->baseeqopr;
+					else
+						op = attrinfo->eqopr;
+				}
+				else if (strcmp(exp_oprname, "<") == 0)
+					op = attrinfo->ltopr;
+				else
+					op = InvalidOid;
+				pfree(exp_oprname);
+			}
+
+			if (require_match_oids)
+			{
+				if (pgs_nulls[PGS_EXP_STAOP1 + k])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d staop%d kind %d expects Oid %u but NULL imported",
+									attnum, k+1, kind,  op)));
+				else
+				{
+					Oid	export_op = DatumGetObjectId(pgs_datums[PGS_EXP_STAOP1 + k]);
+					if (export_op != op)
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("Attribute %d staop%d kind %d expects Oid %u but Oid %u imported",
+										attnum, k+1, kind,  op, export_op)));
+				}
+			}
+			values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(op);
+
+			/* Any NULL stacollN will fail the row */
+			if (pgs_nulls[PGS_STACOLL1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stacoll", k+1)));
+			values[Anum_pg_statistic_stacoll1 - 1 + k] = pgs_datums[PGS_STACOLL1 + k];
+
+			if (require_match_oids)
+			{
+				Oid	export_coll = DatumGetObjectId(pgs_datums[PGS_EXP_STACOLL1 + k]);
+				Oid	import_coll = DatumGetObjectId(pgs_datums[PGS_STACOLL1 + k]);
+
+				if (export_coll != import_coll)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d stacoll%d expects Oid %u but Oid %u imported",
+									attnum, k+1, export_coll, import_coll)));
+			}
+
+			/* stanumbersN - the import query did the required type coercion. */
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_datums[PGS_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_nulls[PGS_STANUMBERS1 + k];
+
+			/* stavaluesN */
+			if (pgs_nulls[PGS_STAVALUES1 + k])
+			{
+				nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			}
+			else
+			{
+				char    *s = TextDatumGetCString(pgs_datums[PGS_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(attrinfo->basetypid),
+								  Int32GetDatum(attrinfo->typmod));
+
+				pfree(s);
+			}
+		}
+
+		/* Add valid tuple to the list */
+		rettuples[tupctr++] = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+	}
+
+	pfree(relattrinfo);
+	*ntuples = tupctr;
+	return rettuples;
+}
+
+/*
+ * Import statistics for a given relation.
+ *
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   "reltuples": number, -- pg_class.reltuples
+ *   "relpages": number, -- pg_class.relpages
+ *   "types": [
+ *         -- export of all pg_type referenced in this json doc
+ *         {
+ *            "oid": number, -- pg_type.oid
+ *            "typname": string, -- pg_type.typname
+ *            "nspname": string -- schema name for the pg_type
+ *         }
+ *      ],
+ *   "collations": [
+ *         -- export all pg_collation reference in this json doc
+ *         {
+ *            "oid": number, -- pg_collation.oid
+ *            "collname": string, -- pg_collation.collname
+ *            "nspname": string -- schema name for the pg_collation
+ *         }
+ *      ],
+ *   "operators": [
+ *         -- export all pg_operator reference in this json doc
+ *         {
+ *            "oid": number, -- pg_operator.oid
+ *            "collname": string, -- pg_oprname
+ *            "nspname": string -- schema name for the pg_operator
+ *         }
+ *      ],
+ *   "attributes": [
+ *         -- export all pg_attribute for the exported relation
+ *         {
+ *            "attnum": number, -- pg_attribute.attnum
+ *            "attname": string, -- pg_attribute.attname
+ *            "atttypid": number, -- pg_attribute.atttypid
+ *            "attcollation": number -- pg_attribute.attcollation
+ *         }
+ *      ],
+ *   "statistics": [
+ *         -- export all pg_statistic for the exported relation
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *      ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+
+ */
+Datum
+pg_import_rel_stats(PG_FUNCTION_ARGS)
+{
+	Oid		relid;
+	bool	validate;
+	bool	require_match_oids;
+
+	const char *sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    relname text, "
+		"    nspname text, "
+		"    reltuples float4,"
+		"    relpages int4, "
+		"    types jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    attributes jsonb, "
+		"    statistics jsonb) ";
+
+	enum
+	{
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_RELTUPLES,
+		BQ_RELPAGES,
+		BQ_TYPES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_ATTRIBUTES,
+		BQ_STATISTICS,
+		NUM_BQ_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid			argtypes[BQ_NARGS] = { JSONBOID };
+	Datum		args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Datum	datums[NUM_BQ_COLS];
+	bool	nulls[NUM_BQ_COLS];
+
+	int32	server_version_num;
+	int32	current_version_num;
+
+	Relation	rel;
+	Relation	sd;
+	HeapTuple  *sdtuples;
+	int			nsdtuples;
+	int			i;
+
+	CatalogIndexState	indstate = NULL;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("relation cannot be NULL")));
+	relid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(sql, BQ_NARGS, argtypes, args, NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("statistic export JSON should return only one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, datums, nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	if (require_match_oids)
+	{
+		char   *curr_relname = SPI_getrelname(rel);
+		char   *curr_nspname = SPI_getnspname(rel);
+		char   *import_relname;
+		char   *import_nspname;
+
+		if (nulls[BQ_RELNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name must match relation name, but is null")));
+
+		if (nulls[BQ_NSPNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name must match schema name, but is null")));
+
+		import_relname = TextDatumGetCString(datums[BQ_RELNAME]);
+		import_nspname = TextDatumGetCString(datums[BQ_NSPNAME]);
+
+		if (strcmp(import_relname, curr_relname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name (%s) must match relation name (%s), but does not",
+							import_relname, curr_relname)));
+
+		if (strcmp(import_nspname, curr_nspname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name (%s) must match schema name (%s), but does not",
+							import_nspname, curr_nspname)));
+
+		pfree(curr_relname);
+		pfree(curr_nspname);
+		pfree(import_relname);
+		pfree(import_nspname);
+	}
+
+	/*
+	 * validations
+	 *
+	 * Potential future validations:
+	 *
+	 *  * all attributes.atttypid values are represented in "types"
+	 *  * all attributes.attcollation values are represented in "types"
+	 *  * attributes.attname is of acceptable length
+	 *  * all non-invalid statistics.opN values are represented in "operators"
+	 *  * all non-invalid statistics.collN values are represented in "collations"
+	 *  * statistincs.kindN values in 0-7
+	 *  * statistics.stanullfrac in range
+	 *  * statistics.stawidth in range
+	 *  * statistics.ndistinct in rage
+	 *
+	 */
+	if (validate)
+	{
+		validate_exported_types(datums[BQ_TYPES], nulls[BQ_TYPES]);
+		validate_exported_collations(datums[BQ_COLLATIONS], nulls[BQ_COLLATIONS]);
+		validate_exported_operators(datums[BQ_OPERATORS], nulls[BQ_OPERATORS]);
+		validate_exported_attributes(datums[BQ_ATTRIBUTES], nulls[BQ_ATTRIBUTES]);
+		validate_exported_statistics(datums[BQ_STATISTICS], nulls[BQ_STATISTICS]);
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	sdtuples = import_pg_statistics(rel, sd, server_version_num,
+									datums[BQ_TYPES], nulls[BQ_TYPES],
+									datums[BQ_COLLATIONS], nulls[BQ_COLLATIONS],
+									datums[BQ_OPERATORS], nulls[BQ_OPERATORS],
+									datums[BQ_ATTRIBUTES], nulls[BQ_ATTRIBUTES],
+									datums[BQ_STATISTICS], nulls[BQ_STATISTICS],
+									require_match_oids, &nsdtuples);
+
+	/* Open index information when we know we need it */
+	indstate = CatalogOpenIndexes(sd);
+
+	/* Delete existing pg_statistic rows for relation to avoid collisions */
+	remove_pg_statistics(rel, sd, false);
+	if (RELKIND_HAS_PARTITIONS(rel->rd_rel->relkind))
+		remove_pg_statistics(rel, sd, true);
+
+	for (i = 0; i < nsdtuples; i++)
+	{
+		CatalogTupleInsertWithInfo(sd, sdtuples[i], indstate);
+		heap_freetuple(sdtuples[i]);
+	}
+
+	CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+	pfree(sdtuples);
+
+	/*
+	 * Update pg_class tuple directly (non-transactionally, same as
+	 * is done in do_analyze().
+	 *
+	 * Only modify pg_class row if changes are to be made
+	 */
+	if (!nulls[BQ_RELTUPLES] || !nulls[BQ_RELPAGES])
+	{
+		Relation		pg_class_rel;
+		HeapTuple		ctup;
+		Form_pg_class	pgcform;
+
+		/*
+		 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+		 * other stat-setting operation can run on it concurrently.
+		 */
+		pg_class_rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+		/* leave if relation could not be opened or locked */
+		if (!pg_class_rel)
+			PG_RETURN_BOOL(false);
+
+		ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+		if (!HeapTupleIsValid(ctup))
+			elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+				 relid);
+
+		pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+		/* leave un-set values alone */
+		if (!nulls[BQ_RELTUPLES])
+			pgcform->reltuples = DatumGetFloat4(datums[BQ_RELTUPLES]);
+
+		if(!nulls[BQ_RELPAGES])
+			pgcform->relpages = DatumGetInt32(datums[BQ_RELPAGES]);
+
+		heap_inplace_update(pg_class_rel, ctup);
+		table_close(pg_class_rel, ShareUpdateExclusiveLock);
+	}
+
+	relation_close(rel, NoLock);
+
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..5ab51c5aa0
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,530 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+ count 
+-------
+     5
+(1 row)
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+ table_stats_json 
+------------------
+(0 rows)
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+ index_stats_json 
+------------------
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+ count 
+-------
+     0
+(1 row)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         0
+ test    |        -1
+(2 rows)
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "types" has duplicate rows with oid = 2
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "collations" has duplicate rows with oid = 1
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "operators" has duplicate rows with oid = 3
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "attributes" has duplicate rows with attnum = 4
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "statistics" has duplicate rows with staattnum = 1, stainherit = f
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..9a80eebeec
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,499 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index cf3de80394..2be0a30d4d 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28732,6 +28732,71 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_rel_stats</primary>
+        </indexterm>
+        <function>pg_import_rel_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>relation_stats</parameter> <type>jsonb</type>, <parameter>validate</parameter> <type>bool</type>, <parameter>require_match_oids</parameter> <type>bool</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces all statistics generated by a previous
+        <command>ANALYZE</command> for the <parameter>relation</parameter>
+        with values specified in <parameter>relation_stats</parameter>.
+       </para>
+       <para>
+        Specifically, the <structname>pg_statistic</structname> rows with a
+        <structfield>statrelid</structfield> matching
+        <parameter>relation</parameter> are replaced with the values derived
+        from <parameter>relation_stats</parameter>, and the
+        <structname>pg_class</structname> entry for
+        <parameter>relation</parameter> is modified, replacing the
+        <structfield>reltuples</structfield> and
+        <structfield>relpages</structfield> with values found in
+        <parameter>relation_stats</parameter>.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function
+        could be used by <command>pg_upgrade</command> and
+        <command>pg_restore</command> to convey the statistics from the old system
+        version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>relation_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para>
+       <para>
+        If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
+        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
+        not match the values specified in <parameter>relation_json</parameter>, as would be expected
+        in a binary upgrade. These assumptions would not be true when restoring from a dump.
+       </para></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.43.0

From c0567d9927055e5de6fe5bef008931e7e1de9c42 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 15 Feb 2024 03:36:30 -0500
Subject: [PATCH v5 2/2] Create pg_import_ext_stats().

This is the extended statistics equivalent of pg_import_rel_stats().

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The exported values stored in the parameter extended_stats are
compared against the existing structure in pg_statistic_ext and are
transformed into pg_statistic_ext_data rows, transactionally replacing
any pre-existing rows for that object.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

This function also allows for tweaking of table statistics in-place,
allowing the user to simulate correlations, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   5 +
 .../statistics/extended_stats_internal.h      |   7 +
 src/backend/statistics/dependencies.c         | 161 +++
 src/backend/statistics/extended_stats.c       | 986 ++++++++++++++++--
 src/backend/statistics/mcv.c                  | 192 ++++
 src/backend/statistics/mvdistinct.c           | 160 +++
 .../regress/expected/stats_export_import.out  | 265 ++++-
 src/test/regress/sql/stats_export_import.sql  | 245 ++++-
 doc/src/sgml/func.sgml                        |  28 +-
 9 files changed, 1976 insertions(+), 73 deletions(-)

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 0e48c08566..701ed3a2c9 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -6125,6 +6125,11 @@
 { oid => '9161', descr => 'adjust time to local time zone',
   proname => 'timezone', provolatile => 's', prorettype => 'timetz',
   proargtypes => 'timetz', prosrc => 'timetz_at_local' },
+{ oid => '9162',
+  descr => 'statistics: import to extended stats object',
+  proname => 'pg_import_ext_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_ext_stats' },
 { oid => '2039', descr => 'hash',
   proname => 'timestamp_hash', prorettype => 'int4', proargtypes => 'timestamp',
   prosrc => 'timestamp_hash' },
diff --git a/src/include/statistics/extended_stats_internal.h b/src/include/statistics/extended_stats_internal.h
index 8eed9b338d..e325a76e63 100644
--- a/src/include/statistics/extended_stats_internal.h
+++ b/src/include/statistics/extended_stats_internal.h
@@ -70,15 +70,22 @@ typedef struct StatsBuildData
 
 
 extern MVNDistinct *statext_ndistinct_build(double totalrows, StatsBuildData *data);
+extern MVNDistinct *statext_ndistinct_import(Oid relid, Datum ndistinct,
+						bool ndististinct_null, Datum attributes,
+						bool attributes_null);
 extern bytea *statext_ndistinct_serialize(MVNDistinct *ndistinct);
 extern MVNDistinct *statext_ndistinct_deserialize(bytea *data);
 
 extern MVDependencies *statext_dependencies_build(StatsBuildData *data);
+extern MVDependencies *statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null);
 extern bytea *statext_dependencies_serialize(MVDependencies *dependencies);
 extern MVDependencies *statext_dependencies_deserialize(bytea *data);
 
 extern MCVList *statext_mcv_build(StatsBuildData *data,
 								  double totalrows, int stattarget);
+extern MCVList *statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **stats);
 extern bytea *statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats);
 extern MCVList *statext_mcv_deserialize(bytea *data);
 
diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c
index 4752b99ed5..e482eca557 100644
--- a/src/backend/statistics/dependencies.c
+++ b/src/backend/statistics/dependencies.c
@@ -18,6 +18,7 @@
 #include "catalog/pg_operator.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "nodes/nodeFuncs.h"
 #include "nodes/nodes.h"
@@ -27,6 +28,7 @@
 #include "parser/parsetree.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/bytea.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
@@ -1829,3 +1831,162 @@ dependencies_clauselist_selectivity(PlannerInfo *root,
 
 	return s1;
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The dependencies serialization is a string that looks like
+ *       {"2 => 3": 0.258241, "1 => 2": 0.0, ...}
+ *
+ *   The integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we
+ *   match them by name.
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *
+ */
+MVDependencies *
+statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null)
+{
+	MVDependencies *result = NULL;
+
+#define DEPS_NARGS 3
+
+	Oid			argtypes[DEPS_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[DEPS_NARGS] = { relid, dependencies, attributes };
+	char		argnulls[DEPS_NARGS] = { ' ',
+					dependencies_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    dep.depord, "
+		"    da.depattrord, "
+		"    da.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN da.exp_attnum < 0 THEN da.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    dep.degree::float8 AS degree, "
+		"    COUNT(*) OVER (PARTITION BY dep.depord) AS num_attrs, "
+		"    MAX(dep.depord) OVER () AS num_deps "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS dep(attrs, degree, depord) "
+		"CROSS JOIN LATERAL unnest( string_to_array( "
+		"         replace(dep.attrs, ' => ', ', '), ', ')::int2[]) "
+		"     WITH ORDINALITY AS da(exp_attnum, depattrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = da.exp_attnum AND da.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY dep.depord, da.depattrord ";
+
+	enum {
+		DEPS_DEPORD = 0,
+		DEPS_DEPATTRORD,
+		DEPS_EXP_ATTNUM,
+		DEPS_EXP_ATTNAME,
+		DEPS_ATTNUM,
+		DEPS_DEGREE,
+		DEPS_NUM_ATTRS,
+		DEPS_NUM_DEPS,
+		NUM_DEPS_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				ndeps;
+	int				j = 0;
+
+	ret = SPI_execute_with_args(sql, DEPS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		ndeps = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								DEPS_NUM_DEPS+1, &isnull);
+		ndeps = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	if (ndeps == 0)
+		result = (MVDependencies *) palloc0(sizeof(MVDependencies));
+	else
+		result = (MVDependencies *) palloc0(offsetof(MVDependencies, deps)
+												   + (ndeps * sizeof(MVDependency *)));
+
+	result->magic = STATS_DEPS_MAGIC;
+	result->type = STATS_DEPS_TYPE_BASIC;
+	result->ndeps = ndeps;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum			datums[NUM_DEPS_COLS];
+		bool			nulls[NUM_DEPS_COLS];
+		int				natts;
+		int				d;
+		int				a;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[DEPS_DEPORD]);
+		d = DatumGetInt32(datums[DEPS_DEPORD]) - 1;
+		Assert(!nulls[DEPS_DEPATTRORD]);
+		a = DatumGetInt32(datums[DEPS_DEPATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New MVDependnecy */
+			Assert(!nulls[DEPS_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[DEPS_NUM_ATTRS]);
+
+			result->deps[d] = palloc0(offsetof(MVDependency, attributes)
+										+ (natts * sizeof(AttrNumber)));
+
+			result->deps[d]->nattributes = natts;
+			Assert(!nulls[DEPS_DEGREE]);
+			result->deps[d]->degree = DatumGetFloat8(datums[DEPS_DEGREE]);
+		}
+
+		if (!nulls[DEPS_ATTNUM])
+			result->deps[d]->attributes[a] = DatumGetInt16(datums[DEPS_ATTNUM]);
+		else if (nulls[DEPS_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency exported attnum cannot be null")));
+		else if (nulls[DEPS_ATTNUM])
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[DEPS_EXP_ATTNUM]);
+
+			if (nulls[DEPS_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Dependency has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[DEPS_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index c5461514d8..841c3d8f55 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -19,12 +19,14 @@
 #include "access/detoast.h"
 #include "access/genam.h"
 #include "access/htup_details.h"
+#include "access/relation.h"
 #include "access/table.h"
 #include "catalog/indexing.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
 #include "executor/executor.h"
+#include "executor/spi.h"
 #include "commands/defrem.h"
 #include "commands/progress.h"
 #include "miscadmin.h"
@@ -32,10 +34,12 @@
 #include "optimizer/clauses.h"
 #include "optimizer/optimizer.h"
 #include "parser/parsetree.h"
+#include "parser/parse_oper.h"
 #include "pgstat.h"
 #include "postmaster/autovacuum.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "statistics/statistics_internal.h"
 #include "utils/acl.h"
 #include "utils/array.h"
 #include "utils/attoptcache.h"
@@ -418,6 +422,83 @@ statext_is_kind_built(HeapTuple htup, char type)
 	return !heap_attisnull(htup, attnum, NULL);
 }
 
+/*
+ * Create a single StatExtEntry from a fetched heap tuple
+ */
+static StatExtEntry *
+statext_create_entry(HeapTuple htup)
+{
+	StatExtEntry *entry;
+	Datum		datum;
+	bool		isnull;
+	int			i;
+	ArrayType  *arr;
+	char	   *enabled;
+	Form_pg_statistic_ext staForm;
+	List	   *exprs = NIL;
+
+	entry = palloc0(sizeof(StatExtEntry));
+	staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
+	entry->statOid = staForm->oid;
+	entry->schema = get_namespace_name(staForm->stxnamespace);
+	entry->name = pstrdup(NameStr(staForm->stxname));
+	entry->stattarget = staForm->stxstattarget;
+	for (i = 0; i < staForm->stxkeys.dim1; i++)
+	{
+		entry->columns = bms_add_member(entry->columns,
+										staForm->stxkeys.values[i]);
+	}
+
+	/* decode the stxkind char array into a list of chars */
+	datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
+								   Anum_pg_statistic_ext_stxkind);
+	arr = DatumGetArrayTypeP(datum);
+	if (ARR_NDIM(arr) != 1 ||
+		ARR_HASNULL(arr) ||
+		ARR_ELEMTYPE(arr) != CHAROID)
+		elog(ERROR, "stxkind is not a 1-D char array");
+	enabled = (char *) ARR_DATA_PTR(arr);
+	for (i = 0; i < ARR_DIMS(arr)[0]; i++)
+	{
+		Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
+			   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
+			   (enabled[i] == STATS_EXT_MCV) ||
+			   (enabled[i] == STATS_EXT_EXPRESSIONS));
+		entry->types = lappend_int(entry->types, (int) enabled[i]);
+	}
+
+	/* decode expression (if any) */
+	datum = SysCacheGetAttr(STATEXTOID, htup,
+							Anum_pg_statistic_ext_stxexprs, &isnull);
+
+	if (!isnull)
+	{
+		char	   *exprsString;
+
+		exprsString = TextDatumGetCString(datum);
+		exprs = (List *) stringToNode(exprsString);
+
+		pfree(exprsString);
+
+		/*
+		 * Run the expressions through eval_const_expressions. This is not
+		 * just an optimization, but is necessary, because the planner
+		 * will be comparing them to similarly-processed qual clauses, and
+		 * may fail to detect valid matches without this.  We must not use
+		 * canonicalize_qual, however, since these aren't qual
+		 * expressions.
+		 */
+		exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
+
+		/* May as well fix opfuncids too */
+		fix_opfuncids((Node *) exprs);
+	}
+
+	entry->exprs = exprs;
+
+	return entry;
+}
+
 /*
  * Return a list (of StatExtEntry) of statistics objects for the given relation.
  */
@@ -443,74 +524,7 @@ fetch_statentries_for_relation(Relation pg_statext, Oid relid)
 
 	while (HeapTupleIsValid(htup = systable_getnext(scan)))
 	{
-		StatExtEntry *entry;
-		Datum		datum;
-		bool		isnull;
-		int			i;
-		ArrayType  *arr;
-		char	   *enabled;
-		Form_pg_statistic_ext staForm;
-		List	   *exprs = NIL;
-
-		entry = palloc0(sizeof(StatExtEntry));
-		staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
-		entry->statOid = staForm->oid;
-		entry->schema = get_namespace_name(staForm->stxnamespace);
-		entry->name = pstrdup(NameStr(staForm->stxname));
-		entry->stattarget = staForm->stxstattarget;
-		for (i = 0; i < staForm->stxkeys.dim1; i++)
-		{
-			entry->columns = bms_add_member(entry->columns,
-											staForm->stxkeys.values[i]);
-		}
-
-		/* decode the stxkind char array into a list of chars */
-		datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
-									   Anum_pg_statistic_ext_stxkind);
-		arr = DatumGetArrayTypeP(datum);
-		if (ARR_NDIM(arr) != 1 ||
-			ARR_HASNULL(arr) ||
-			ARR_ELEMTYPE(arr) != CHAROID)
-			elog(ERROR, "stxkind is not a 1-D char array");
-		enabled = (char *) ARR_DATA_PTR(arr);
-		for (i = 0; i < ARR_DIMS(arr)[0]; i++)
-		{
-			Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
-				   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
-				   (enabled[i] == STATS_EXT_MCV) ||
-				   (enabled[i] == STATS_EXT_EXPRESSIONS));
-			entry->types = lappend_int(entry->types, (int) enabled[i]);
-		}
-
-		/* decode expression (if any) */
-		datum = SysCacheGetAttr(STATEXTOID, htup,
-								Anum_pg_statistic_ext_stxexprs, &isnull);
-
-		if (!isnull)
-		{
-			char	   *exprsString;
-
-			exprsString = TextDatumGetCString(datum);
-			exprs = (List *) stringToNode(exprsString);
-
-			pfree(exprsString);
-
-			/*
-			 * Run the expressions through eval_const_expressions. This is not
-			 * just an optimization, but is necessary, because the planner
-			 * will be comparing them to similarly-processed qual clauses, and
-			 * may fail to detect valid matches without this.  We must not use
-			 * canonicalize_qual, however, since these aren't qual
-			 * expressions.
-			 */
-			exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
-
-			/* May as well fix opfuncids too */
-			fix_opfuncids((Node *) exprs);
-		}
-
-		entry->exprs = exprs;
-
+		StatExtEntry *entry = statext_create_entry(htup);
 		result = lappend(result, entry);
 	}
 
@@ -2636,3 +2650,839 @@ make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
 
 	return result;
 }
+
+/*
+ * examine_rel_attribute -- pre-analysis of a single column
+ *
+ * Determine whether the column is analyzable; if so, create and initialize
+ * a VacAttrStats struct for it.  If not, return NULL.
+ *
+ * If index_expr isn't NULL, then we're trying to import an expression index,
+ * and index_expr is the expression tree representing the column's data.
+ */
+static VacAttrStats *
+examine_rel_attribute(Relation onerel, int attnum, Node *index_expr)
+{
+	Form_pg_attribute attr = TupleDescAttr(onerel->rd_att, attnum - 1);
+	HeapTuple		typtuple;
+	VacAttrStats   *stats;
+	int				i;
+	bool			ok;
+
+	/* Never analyze dropped columns */
+	if (attr->attisdropped)
+		return NULL;
+
+	/*
+	 * Create the VacAttrStats struct.
+	 */
+	stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
+	stats->attstattarget = 1; /* Any nonzero value */
+
+	/*
+	 * When analyzing an expression index, believe the expression tree's type
+	 * not the column datatype --- the latter might be the opckeytype storage
+	 * type of the opclass, which is not interesting for our purposes.  (Note:
+	 * if we did anything with non-expression index columns, we'd need to
+	 * figure out where to get the correct type info from, but for now that's
+	 * not a problem.)	It's not clear whether anyone will care about the
+	 * typmod, but we store that too just in case.
+	 */
+	if (index_expr)
+	{
+		stats->attrtypid = exprType(index_expr);
+		stats->attrtypmod = exprTypmod(index_expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(onerel->rd_indcollation[attnum - 1]))
+			stats->attrcollid = onerel->rd_indcollation[attnum - 1];
+		else
+			stats->attrcollid = exprCollation(index_expr);
+	}
+	else
+	{
+		stats->attrtypid = attr->atttypid;
+		stats->attrtypmod = attr->atttypmod;
+		stats->attrcollid = attr->attcollation;
+	}
+
+	typtuple = SearchSysCacheCopy1(TYPEOID,
+								   ObjectIdGetDatum(stats->attrtypid));
+	if (!HeapTupleIsValid(typtuple))
+		elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
+	stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
+	stats->anl_context = NULL;
+	stats->tupattnum = attnum;
+
+	/*
+	 * The fields describing the stats->stavalues[n] element types default to
+	 * the type of the data being analyzed, but the type-specific typanalyze
+	 * function can change them if it wants to store something else.
+	 */
+	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
+	{
+		stats->statypid[i] = stats->attrtypid;
+		stats->statyplen[i] = stats->attrtype->typlen;
+		stats->statypbyval[i] = stats->attrtype->typbyval;
+		stats->statypalign[i] = stats->attrtype->typalign;
+	}
+
+	/*
+	 * Call the type-specific typanalyze function.  If none is specified, use
+	 * std_typanalyze().
+	 */
+	if (OidIsValid(stats->attrtype->typanalyze))
+		ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
+										   PointerGetDatum(stats)));
+	else
+		ok = std_typanalyze(stats);
+
+	if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
+	{
+		heap_freetuple(typtuple);
+		pfree(stats);
+		return NULL;
+	}
+
+	return stats;
+}
+
+
+static Datum
+import_expressions(Datum stxdexpr, bool stxdexpr_null,
+				   Datum operators, bool operators_null,
+				   VacAttrStats **expr_stats, int nexprs)
+{
+
+#define EXPR_NARGS 2
+
+	Oid			argtypes[EXPR_NARGS] = { JSONBOID, JSONBOID };
+	Datum		args[EXPR_NARGS] = { stxdexpr, operators };
+	char		argnulls[EXPR_NARGS] = {
+					stxdexpr_null ? 'n' : ' ',
+					operators_null ? 'n' : ' ' };
+
+	const char *sql =
+		"WITH exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS eo(oid oid, oprname text) "
+		") "
+		"SELECT s.*, "
+		"       eo1.oprname AS eoprname1, "
+		"       eo2.oprname AS eoprname2, "
+		"       eo3.oprname AS eoprname3, "
+		"       eo4.oprname AS eoprname4, "
+		"       eo5.oprname AS eoprname5 "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = s.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = s.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = s.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = s.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = s.staop5 ";
+
+	enum
+	{
+		EXPR_ATTNUM = 0,
+		EXPR_STAINHERIT,
+		EXPR_STANULLFRAC,
+		EXPR_STAWIDTH,
+		EXPR_STADISTINCT,
+		EXPR_STAKIND1,
+		EXPR_STAKIND2,
+		EXPR_STAKIND3,
+		EXPR_STAKIND4,
+		EXPR_STAKIND5,
+		EXPR_STAOP1,
+		EXPR_STAOP2,
+		EXPR_STAOP3,
+		EXPR_STAOP4,
+		EXPR_STAOP5,
+		EXPR_STACOLL1,
+		EXPR_STACOLL2,
+		EXPR_STACOLL3,
+		EXPR_STACOLL4,
+		EXPR_STACOLL5,
+		EXPR_STANUMBERS1,
+		EXPR_STANUMBERS2,
+		EXPR_STANUMBERS3,
+		EXPR_STANUMBERS4,
+		EXPR_STANUMBERS5,
+		EXPR_STAVALUES1,
+		EXPR_STAVALUES2,
+		EXPR_STAVALUES3,
+		EXPR_STAVALUES4,
+		EXPR_STAVALUES5,
+		EXPR_EOPRNAME1,
+		EXPR_EOPRNAME2,
+		EXPR_EOPRNAME3,
+		EXPR_EOPRNAME4,
+		EXPR_EOPRNAME5,
+		NUM_EXPR_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				e;
+
+	ArrayBuildState *astate = NULL;
+
+	Relation	pgsd;
+	HeapTuple	pgstup;
+	Oid			pgstypoid;
+	FmgrInfo	finfo;
+
+	pgsd = table_open(StatisticRelationId, RowExclusiveLock);
+	pgstypoid = get_rel_type_id(StatisticRelationId);
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	if (!OidIsValid(pgstypoid))
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("relation \"%s\" does not have a composite type",
+						"pg_statistic")));
+
+	ret = SPI_execute_with_args(sql, EXPR_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (nexprs != tuptable->numvals)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export expected %d stxdexpr rows but found %lu",
+					 nexprs, tuptable->numvals)));
+
+	if (nexprs == 0)
+		astate = accumArrayResult(astate,
+								  (Datum) 0,
+								  true,
+								  pgstypoid,
+								  CurrentMemoryContext);
+
+	for (e = 0; e < nexprs; e++)
+	{
+		Datum	values[Natts_pg_statistic] = { 0 };
+		bool	nulls[Natts_pg_statistic] = { false };
+
+		Datum	rs_datums[NUM_EXPR_COLS];
+		bool	rs_nulls[NUM_EXPR_COLS];
+
+		VacAttrStats   *stats = expr_stats[e];
+
+		Oid 	basetypoid;
+		Oid		ltopr;
+		Oid 	baseltopr;
+		Oid		eqopr;
+		Oid 	baseeqopr;
+		int 	k;
+
+		/*
+		 * If if the stat is an array, then we want the base element
+		 * type. This mimics the calculation in get_attrinfo().
+		 */
+		get_sort_group_operators(stats->attrtypid,
+								 false, false, false,
+								 &ltopr, &eqopr, NULL,
+								 NULL);
+		basetypoid = get_base_element_type(stats->attrtypid);
+		if (basetypoid == InvalidOid)
+			basetypoid = stats->attrtypid;
+		get_sort_group_operators(basetypoid,
+								 false, false, false,
+								 &baseltopr, &baseeqopr, NULL,
+								 NULL);
+
+		heap_deform_tuple(tuptable->vals[e], tuptable->tupdesc,
+						  rs_datums, rs_nulls);
+
+		/* These values are not derived from either vac stats or exported stats */
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
+
+		if (rs_nulls[EXPR_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stanullfrac")));
+
+		if (rs_nulls[EXPR_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stawidth")));
+
+		if (rs_nulls[EXPR_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = rs_datums[EXPR_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = rs_datums[EXPR_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = rs_datums[EXPR_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind = 0;
+			Oid		op = InvalidOid;
+
+			if (!rs_nulls[EXPR_STAKIND1 + k])
+			{
+				kind = Int16GetDatum(rs_datums[EXPR_STAKIND1 + k]);
+
+				if (!rs_nulls[EXPR_EOPRNAME1 + k])
+				{
+					char *s = TextDatumGetCString(rs_datums[EXPR_EOPRNAME1 + k]);
+
+					if (strcmp(s, "=") == 0)
+					{
+						/*
+						 * MCELEM stat arrays are of the same type as the
+						 * array base element type and are eqopr
+						 */
+						if ((kind == STATISTIC_KIND_MCELEM) ||
+							(kind == STATISTIC_KIND_DECHIST))
+							op = baseeqopr;
+						else
+							op = eqopr;
+					}
+					else if (strcmp(s, "<") == 0)
+						op = ltopr;
+					else
+						op = InvalidOid;
+
+					pfree(s);
+				}
+			}
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = kind;
+			values[Anum_pg_statistic_staop1 - 1 + k] = op;
+
+			/* rely on vacattrstat */
+			values[Anum_pg_statistic_stacoll1 - 1 + k] =
+				ObjectIdGetDatum(stats->stacoll[k]);
+
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_datums[EXPR_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_nulls[EXPR_STANUMBERS1 + k];
+
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] =
+				rs_nulls[EXPR_STAVALUES1 + k];
+			if (rs_nulls[EXPR_STAVALUES1 + k])
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			else
+			{
+				char *s = TextDatumGetCString(rs_datums[EXPR_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(basetypoid),
+								  Int32GetDatum(stats->attrtypmod));
+
+				pfree(s);
+			}
+		}
+
+		pgstup = heap_form_tuple(RelationGetDescr(pgsd), values, nulls);
+
+		astate = accumArrayResult(astate,
+								  heap_copy_tuple_as_datum(pgstup, RelationGetDescr(pgsd)),
+								  false,
+								  pgstypoid,
+								  CurrentMemoryContext);
+	}
+
+	table_close(pgsd, RowExclusiveLock);
+
+	return makeArrayResult(astate, CurrentMemoryContext);
+}
+
+/*
+ * Import statistics for a given extended statistics object.
+ *
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "stxoid": number, -- pg_stat_ext.stxoid
+ *   "stxname": string, -- pg_stat_ext.stxname
+ *   "stxnspname": string, -- schema name for the statistics object
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   -- stxkeys cast to text to aid array_in()
+ *   "stxkeys": string, -- pg_statistic_ext.stxkind::text
+ *   -- stxndistinct and stxdndepencies only on v10-v11
+ *   "stxndistinct": string, -- pg_statistic_ext.stxndistinct::text
+ *   "stxdependencies": string, -- pg_statistic_ext.stxdependencies::text
+ *   -- data is on v12+
+ *   "data": [
+ *     {
+ *       -- stxdinherit is on v15+
+ *       "stxdinherit": bool, -- pg_statistic_ext_data.stxdinherit
+ *       -- stxdndistinct and stxddependencies are on v12+
+ *       "stxdndistinct": text, -- pg_statistic_ext_data.stxdndisinct::text
+ *       "stxddependencies": text, -- pg_statistic_ext_data.stxddepencies::text
+ *       -- stxdexpr is on v12+
+ *       "stxdmcv": [
+ *         {
+ *           "index": number,
+ *           "nulls": [bool],
+ *           "values": [text],
+ *           "frequency": number,
+ *           "base_frequency": number
+ *         }
+ *       ],
+ *       -- stxdexpr is on v14+
+ *       "stxdexpr": [
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *       ]
+ *     }
+ *   ],
+ *   "types": [
+ *     -- export of all pg_type referenced in this json doc
+ *	   {
+ *        "oid": number, -- pg_type.oid
+ *        "typname": string, -- pg_type.typname
+ *        "nspname": string -- schema name for the pg_type
+ *     }
+ *   ],
+ *   "collations": [
+ *     -- export all pg_collation reference in this json doc
+ *     {
+ *        "oid": number, -- pg_collation.oid
+ *        "collname": string, -- pg_collation.collname
+ *        "nspname": string -- schema name for the pg_collation
+ *     }
+ *   ],
+ *   "operators": [
+ *     -- export all pg_operator reference in this json doc
+ *     {
+ *        "oid": number, -- pg_operator.oid
+ *        "collname": string, -- pg_oprname
+ *        "nspname": string -- schema name for the pg_operator
+ *     }
+ *   ],
+ *   "attributes": [
+ *     -- export all pg_attribute for the exported relation
+ *     {
+ *        "attnum": number, -- pg_attribute.attnum
+ *        "attname": string, -- pg_attribute.attname
+ *        "atttypid": number, -- pg_attribute.atttypid
+ *        "attcollation": number -- pg_attribute.attcollation
+ *     }
+ *   ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+ *
+ * Statistics imported from version 15 and higher can potentially have two
+ * result rows, one with stxdinherit = false and one for stxdinherit = true
+ *
+ */
+Datum
+pg_import_ext_stats(PG_FUNCTION_ARGS)
+{
+	const char *bq_sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    stxoid Oid, "
+		"    reloid Oid, "
+		"    stxname text, "
+		"    stxnspname text, "
+		"    relname text, "
+		"    nspname text, "
+		"    stxkeys text, "
+		"    stxkind text, "
+		"    stxndistinct text, "
+		"    stxdependencies text, "
+		"    data jsonb, "
+		"    attributes jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    types jsonb) ";
+
+	enum {
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_STXOID,
+		BQ_RELOID,
+		BQ_STXNAME,
+		BQ_STXNSPNAME,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_STXKEYS,
+		BQ_STXKIND,
+		BQ_STXNDISTINCT,
+		BQ_STXDEPENDENCIES,
+		BQ_DATA,
+		BQ_ATTRIBUTES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_TYPES,
+		NUM_BQ_COLS
+	};
+
+	/* All versions of the STXD query have the same column signature */
+	enum {
+		STXD_INHERIT = 0,
+		STXD_NDISTINCT,
+		STXD_DEPENDENCIES,
+		STXD_MCV,
+		STXD_EXPR,
+		NUM_STXD_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid		stxid;
+	bool	validate;
+	bool	require_match_oids;
+
+	Oid		bq_argtypes[BQ_NARGS] = { JSONBOID };
+	Datum	bq_args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Relation	rel;
+	TupleDesc	tupdesc;
+	int			natts;
+
+	HeapTuple	etup;
+	Relation	sd;
+
+	Form_pg_statistic_ext	stxform;
+
+	StatExtEntry   *stxentry;
+	VacAttrStats  **relstats; /* all relations attributes */
+	VacAttrStats  **extstats; /* entries relevenat to the extstat */
+	VacAttrStats  **expr_stats; /* expressions in the extstat */
+	int				nexprs;
+	int				ncols;
+
+	Datum	bq_datums[NUM_BQ_COLS];
+	bool	bq_nulls[NUM_BQ_COLS];
+
+	int		i;
+	int32	server_version_num;
+	int32	current_version_num;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("extended statistics oid cannot be NULL")));
+	stxid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	bq_args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	etup = SearchSysCacheCopy1(STATEXTOID, ObjectIdGetDatum(stxid));
+	if (!HeapTupleIsValid(etup))
+		elog(ERROR, "pg_statistic_ext entry for oid %u vanished during statistics import",
+			 stxid);
+
+	stxform = (Form_pg_statistic_ext) GETSTRUCT(etup);
+
+	rel = relation_open(stxform->stxrelid, ShareUpdateExclusiveLock);
+
+	tupdesc = RelationGetDescr(rel);
+	natts = tupdesc->natts;
+
+	relstats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
+	for (i = 0; i < natts; i++)
+		relstats[i] = examine_rel_attribute(rel, i+1, NULL);
+
+	stxentry = statext_create_entry(etup);
+	extstats = lookup_var_attr_stats(rel, stxentry->columns, stxentry->exprs,
+									 natts, relstats);
+
+	/* only the stats that were derived from pg_statistic_ext */
+	ncols = bms_num_members(stxentry->columns);
+	expr_stats = &extstats[ncols];
+	nexprs = list_length(stxentry->exprs);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(bq_sql, BQ_NARGS, bq_argtypes, bq_args,
+								NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("pg_statistic_ext export JSON should return exactly one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, bq_datums, bq_nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (bq_nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (bq_nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(bq_datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(bq_datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	if (validate)
+	{
+		validate_exported_types(bq_datums[BQ_TYPES], bq_nulls[BQ_TYPES]);
+		validate_exported_collations(bq_datums[BQ_COLLATIONS], bq_nulls[BQ_COLLATIONS]);
+		validate_exported_operators(bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS]);
+		validate_exported_attributes(bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+	}
+
+	if (server_version_num >= 120000)
+	{
+		/* pg_statistic_ext_data export for modern versions */
+
+#define STXD_NARGS 1
+
+		Oid		stxd_argtypes[STXD_NARGS] = { JSONBOID };
+		Datum	stxd_args[STXD_NARGS] = { bq_datums[BQ_DATA] };
+		char	stxd_nulls[STXD_NARGS] = { bq_nulls[BQ_DATA] ? 'n' : ' ' };
+
+		const char *stxd_sql =
+			"SELECT d.* "
+			"FROM jsonb_to_recordset($1) AS d ( "
+			"    stxdinherit bool, "
+			"    stxdndistinct text, "
+			"    stxddependencies text, "
+			"    stxdmcv jsonb, "
+			"    stxdexpr jsonb) "
+			"ORDER BY d.stxdinherit ";
+
+		/* Versions 12+ cannot have ndistinct or dependencies on the base query */
+		if (!bq_nulls[BQ_STXNDISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxndistinct not allowed on exports of servers v12 and later"),
+					 errhint("Use stxdndistinct instead")));
+
+		if(!bq_nulls[BQ_STXDEPENDENCIES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdependencies not allowed on exports of servers v12 and later"),
+					 errhint("Use stxddependencies instead")));
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 0);
+#undef STXD_NARGS
+	}
+	else
+	{
+#define STXD_NARGS 2
+		Oid		stxd_argtypes[STXD_NARGS] = {
+					TEXTOID,
+					TEXTOID };
+		Datum	stxd_args[STXD_NARGS] = {
+					bq_datums[BQ_STXNDISTINCT],
+					bq_datums[BQ_STXDEPENDENCIES] };
+		char	stxd_nulls[STXD_NARGS] = {
+					bq_nulls[BQ_STXNDISTINCT] ? 'n' : ' ',
+					bq_nulls[BQ_DATA]  ? 'n' : ' ' };
+
+		/* pg_statistic_ext_data export for versions prior to the table existing */
+		const char *stxd_sql =
+			"SELECT "
+			"	NULL::boolean AS stxdinherit, "
+			"   $1 AS stxdndistinct, "
+			"   $2 AS stxddependencies, "
+			"   NULL::jsonb AS stxdmcv, "
+			"   NULL::jsonb AS stxdexpr ";
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 2);
+
+#undef STXD_NARGS
+	}
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	/* overwrite previous tuptable */
+	tuptable = SPI_tuptable;
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum			stxd_datums[NUM_BQ_COLS];
+		bool			stxd_nulls[NUM_BQ_COLS];
+		bool			inh;
+		MCVList		   *mcvlist;
+		MVDependencies *dependencies;
+		MVNDistinct	   *ndistinct;
+		Datum			exprs;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, stxd_datums,
+						  stxd_nulls);
+
+		if ((!stxd_nulls[STXD_MCV]) && (server_version_num < 120000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdmv not allowed on exports of servers berfore v12")));
+
+		if ((!stxd_nulls[STXD_EXPR]) && (server_version_num < 140000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdexpr not allowed on exports of servers berfore v14")));
+
+		if ((!stxd_nulls[STXD_INHERIT]) && (server_version_num < 150000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Extended statistics from servers prior to v15 cannot contain inherited stats")));
+
+		/* Versions prior to v15 never have stxdinhert set */
+		if (stxd_nulls[STXD_INHERIT])
+			inh = false;
+		else
+			inh = DatumGetBool(stxd_datums[STXD_INHERIT]);
+
+		ndistinct = statext_ndistinct_import(stxform->stxrelid,
+						stxd_datums[STXD_NDISTINCT], stxd_nulls[STXD_NDISTINCT],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		dependencies = statext_dependencies_import(stxform->stxrelid,
+						stxd_datums[STXD_DEPENDENCIES],
+						stxd_nulls[STXD_DEPENDENCIES],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		mcvlist = statext_mcv_import(stxd_datums[STXD_MCV], stxd_nulls[STXD_MCV],
+									 extstats);
+
+		exprs = import_expressions(stxd_datums[STXD_EXPR], stxd_nulls[STXD_EXPR],
+								   bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS],
+								   expr_stats, nexprs);
+
+		statext_store(stxentry->statOid, inh, ndistinct, dependencies, mcvlist, exprs, extstats);
+	}
+
+	relation_close(rel, NoLock);
+	table_close(sd, RowExclusiveLock);
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index 6255cd1f4f..3bafde83d6 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -20,6 +20,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "fmgr.h"
 #include "funcapi.h"
 #include "nodes/nodeFuncs.h"
@@ -2177,3 +2178,194 @@ mcv_clause_selectivity_or(PlannerInfo *root, StatisticExtInfo *stat,
 
 	return s;
 }
+
+/*
+ * statext_mcv_import
+ *
+ * The mcv serialization is the json equivalent of the
+ * pg_mcv_list_items() result set:
+ * [
+ *   {
+ *     "index": number,
+ *     "values": [string],
+ *     "nulls": [bool],
+ *     "frequency": number,
+ *     "base_frequency": number
+ *   }
+ * ]
+ *
+ * The values are text strings that must be converted into datums of the type
+ * appropriate for their corresponding dimension. This means that we must
+ * cast individual datums rather than trying to use array_in().
+ *
+ */
+MCVList *
+statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **extstats)
+{
+	const char *sql =
+		"SELECT m.*, array_length(m.nulls,1) AS ndims "
+		"FROM jsonb_to_recordset($1) AS m(index integer, values text[], "
+		"         nulls boolean[], frequency float8, base_frequency float8) "
+		"ORDER BY m.index ";
+
+	enum {
+		MCVS_INDEX = 0,
+		MCVS_VALUES,
+		MCVS_NULLS,
+		MCVS_FREQUENCY,
+		MCVS_BASE_FREQUENCY,
+		MCVS_NDIMS,
+		NUM_MCVS_COLS
+	};
+
+#define MCVS_NARGS 1
+
+	Oid		argtypes[MCVS_NARGS] = { JSONBOID };
+	Datum	args[MCVS_NARGS] = { mcv };
+	char	argnulls[MCVS_NARGS] = { mcv_null ? 'n' : ' ' };
+	int		nitems = 0;
+	int		ndims = 0;
+	int		ret;
+	int		i;
+
+	MCVList		   *mcvlist;
+	SPITupleTable  *tuptable;
+	Oid				ioparams[STATS_MAX_DIMENSIONS];
+	FmgrInfo		finfos[STATS_MAX_DIMENSIONS];
+
+	ret = SPI_execute_with_args(sql, MCVS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		/* ndims will be same for all rows, so just check first one */
+		bool	isnull;
+		Datum	d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								  MCVS_NDIMS+1, &isnull);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of mcv dimensions")));
+
+		ndims = DatumGetInt32(d);
+		nitems = tuptable->numvals;
+	}
+
+	mcvlist = (MCVList *) palloc0(offsetof(MCVList, items) +
+								  (sizeof(MCVItem) * nitems));
+
+	mcvlist->magic = STATS_MCV_MAGIC;
+	mcvlist->type = STATS_MCV_TYPE_BASIC;
+	mcvlist->nitems = nitems;
+	mcvlist->ndimensions = ndims;
+
+	/* We will need these input functions $nitems times. */
+	for (i = 0; i < ndims; i++)
+	{
+		Oid		typid = extstats[i]->attrtypid;
+		Oid		infunc;
+
+		mcvlist->types[i] = typid;
+		getTypeInputInfo(typid, &infunc, &ioparams[i]);
+		fmgr_info(infunc, &finfos[i]);
+	}
+
+	for (i = 0; i < nitems; i++)
+	{
+		MCVItem	   *item = &mcvlist->items[i];
+		Datum		datums[NUM_MCVS_COLS];
+		bool		nulls[NUM_MCVS_COLS];
+		ArrayType  *arr;
+		Datum      *elems;
+		bool       *elnulls;
+		int         nelems;
+
+		int			d;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, datums, nulls);
+
+		if (nulls[MCVS_VALUES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"values")));
+		if (nulls[MCVS_NULLS])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"nulls")));
+		if (nulls[MCVS_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"frequency")));
+		if (nulls[MCVS_BASE_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"base_frequency")));
+
+		item->frequency = DatumGetFloat8(datums[MCVS_FREQUENCY]);
+		item->base_frequency = DatumGetFloat8(datums[MCVS_BASE_FREQUENCY]);
+		item->values = (Datum *) palloc(sizeof(Datum) * ndims);
+		item->isnull = (bool *) palloc(sizeof(bool) * ndims);
+
+		arr = DatumGetArrayTypeP(datums[MCVS_NULLS]);
+		deconstruct_array(arr, BOOLOID, 1, true, 'c', &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"nulls", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			if (elnulls[d])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("extended statistic mcv %s array cannot contain NULL values",
+								"nulls")));
+			item->isnull[d] = DatumGetBool(elems[d]);
+		}
+
+		arr = DatumGetArrayTypeP(datums[MCVS_VALUES]);
+		deconstruct_array_builtin(arr, TEXTOID, &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"values", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			/* if the element is a known NULL, nothing to decode */
+			if (item->isnull[d])
+				item->values[d] = (Datum) 0;
+			else
+			{
+				char   *s;
+
+				if (elnulls[d])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("extended statistic mcv nulls array in conflict with values array")));
+
+				s = TextDatumGetCString(elems[d]);
+
+				item->values[d] = InputFunctionCall(&finfos[d], s, ioparams[d],
+													extstats[d]->attrtypmod);
+				pfree(s);
+			}
+		}
+	}
+
+	return mcvlist;
+}
diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c
index ee1134cc37..d84eee47ee 100644
--- a/src/backend/statistics/mvdistinct.c
+++ b/src/backend/statistics/mvdistinct.c
@@ -28,9 +28,11 @@
 #include "access/htup_details.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -698,3 +700,161 @@ generate_combinations(CombinationGenerator *state)
 
 	pfree(current);
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The ndinstinct serialization is a string that looks like
+ *       {"2, 3": 1521, "3, -1": 4}
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *   The key side integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we match
+ *   them by name.
+ *
+ *   Negative integers represent expressions columns that have no
+ *   corresponding match in the exported attributes. We leave those
+ *   attnums as-is. Positive integers are looked up in the exported
+ *   attributes and the attname there is then compared to pg_attribute
+ *   names in the underlying table, and that tuples attnum is used instead.
+ */
+MVNDistinct *
+statext_ndistinct_import(Oid relid, Datum ndistinct, bool ndistinct_null,
+						 Datum attributes, bool attributes_null)
+{
+	MVNDistinct	   *result;
+	int				nitems;
+
+#define NDIST_NARGS 3
+
+	Oid			argtypes[NDIST_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[NDIST_NARGS] = { relid, ndistinct , attributes };
+	char		argnulls[NDIST_NARGS] = { ' ',
+					ndistinct_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    i.itemord, "
+		"    a.attrord, "
+		"    a.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN a.exp_attnum < 0 THEN a.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    i.ndistinct::float8 AS ndistinct, "
+		"    COUNT(*) OVER (PARTITION BY i.itemord) AS num_attrs, "
+		"    MAX(i.itemord) OVER () AS num_items "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS i(attrlist, ndistinct, itemord) "
+		"CROSS JOIN LATERAL unnest(string_to_array(i.attrlist, ', ')::int2[]) "
+		"     WITH ORDINALITY AS a(exp_attnum, attrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = a.exp_attnum AND a.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY i.itemord, a.attrord ";
+
+	enum {
+		NDIST_ITEMORD = 0,
+		NDIST_ATTRORD,
+		NDIST_EXP_ATTNUM,
+		NDIST_EXP_ATTNAME,
+		NDIST_ATTNUM,
+		NDIST_NDISTINCT,
+		NDIST_NUM_ATTRS,
+		NDIST_NUM_ITEMS,
+		NUM_NDIST_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				j;
+
+	ret = SPI_execute_with_args(sql, NDIST_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		nitems = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								NDIST_NUM_ITEMS+1, &isnull);
+		nitems = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	result = palloc(offsetof(MVNDistinct, items) +
+					(nitems * sizeof(MVNDistinctItem)));
+	result->magic = STATS_NDISTINCT_MAGIC;
+	result->type = STATS_NDISTINCT_TYPE_BASIC;
+	result->nitems = nitems;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum	datums[NUM_NDIST_COLS];
+		bool	nulls[NUM_NDIST_COLS];
+		int		i;
+		int		a;
+		int		natts;
+
+		MVNDistinctItem *item;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[NDIST_ITEMORD]);
+		i = DatumGetInt32(datums[NDIST_ITEMORD]) - 1;
+		item = &result->items[i];
+		Assert(!nulls[NDIST_ATTRORD]);
+		a = DatumGetInt32(datums[NDIST_ATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New item */
+			Assert(!nulls[NDIST_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[NDIST_NUM_ATTRS]);
+			item->nattributes = natts;
+			item->attributes = palloc(sizeof(AttrNumber) * natts);
+			Assert(!nulls[NDIST_NDISTINCT]);
+			item->ndistinct = DatumGetFloat8(datums[NDIST_NDISTINCT]);
+		}
+
+		if (!nulls[NDIST_ATTNUM])
+			item->attributes[a] =
+				DatumGetInt16(datums[NDIST_ATTNUM]);
+		else if (nulls[NDIST_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ndistinct exported attnum cannot be null")));
+		else
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[NDIST_EXP_ATTNUM]);
+
+			if (nulls[NDIST_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("ndistinct has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[NDIST_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
index 5ab51c5aa0..9d17947583 100644
--- a/src/test/regress/expected/stats_export_import.out
+++ b/src/test/regress/expected/stats_export_import.out
@@ -22,6 +22,7 @@ SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.comple
 UNION ALL
 SELECT 4, 'four', NULL, NULL;
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
 -- Capture pg_statistic values for table and index
@@ -44,6 +45,25 @@ FROM stats_export_import.pg_statistic_capture;
      5
 (1 row)
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ count 
+-------
+     1
+(1 row)
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -323,6 +343,173 @@ WHERE :'debug'::boolean;
 ------------------
 (0 rows)
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+ ext_stats_json 
+----------------
+(0 rows)
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
@@ -334,12 +521,14 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
--- Create empty copy tables
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Verify no stats for these new tables
 SELECT COUNT(*)
 FROM pg_statistic
@@ -475,6 +664,19 @@ SELECT pg_import_rel_stats(
  t
 (1 row)
 
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        true)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ pg_import_ext_stats 
+---------------------
+ t
+(1 row)
+
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
         stakind1, stakind2, stakind3, stakind4, stakind5,
@@ -528,3 +730,62 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
index 9a80eebeec..cbe94b9273 100644
--- a/src/test/regress/sql/stats_export_import.sql
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -26,6 +26,7 @@ UNION ALL
 SELECT 4, 'four', NULL, NULL;
 
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
@@ -47,6 +48,22 @@ WHERE starelid IN ('stats_export_import.test'::regclass,
 SELECT COUNT(*)
 FROM stats_export_import.pg_statistic_capture;
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -322,19 +339,186 @@ WHERE r.oid = 'stats_export_import.is_odd'::regclass
 SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
 WHERE :'debug'::boolean;
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
 
--- Create empty copy tables
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Verify no stats for these new tables
 SELECT COUNT(*)
@@ -456,6 +640,15 @@ SELECT pg_import_rel_stats(
         true,
         true);
 
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        true)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
         stakind1, stakind2, stakind3, stakind4, stakind5,
@@ -497,3 +690,51 @@ FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
+
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 2be0a30d4d..6f41c7a292 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28787,12 +28787,38 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
        </para>
        <para>
         If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
-        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        then the import will fail if the imported oids for <structname>pg_type</structname>,
         <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
         not match the values specified in <parameter>relation_json</parameter>, as would be expected
         in a binary upgrade. These assumptions would not be true when restoring from a dump.
        </para></entry>
       </row>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_ext_stats</primary>
+        </indexterm>
+        <function>pg_import_ext_stats</function> ( <parameter>extended statisticss object</parameter> <type>oid</type>, <parameter>extended_stats</parameter> <type>jsonb</type> <parameter>validate</parameter> <type>boolean</type>, <parameter>require_match_oids</parameter> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_statistic_ext_data</structname> rows for the
+        <structfield>oid</structfield> matching
+        <parameter>extended statistics object</parameter> are transactionally
+        replaced with the values found in <parameter>extended_stats</parameter>.
+        The purpose of this function is to apply statistics values in an upgrade
+        situation that are "good enough" for system operation until they are
+        replaced by the next auto-analyze. This function could be used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>extended_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para></entry>
+      </row>
      </tbody>
     </tgroup>
    </table>
-- 
2.43.0

From 3376153585154289878fde8fbcd1cd8bddad8c52 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 20 Feb 2024 01:00:43 -0500
Subject: [PATCH v6 1/4] Create pg_import_rel_stats.

The function pg_import_rel_stats imports pg_class rowcount,
pagecount, and pg_statistic data for a given relation.

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The function takes a jsonb parameter which contains the generated
statistics for one relaton, the format of which varies by the version
of the server that exported it. The function takes that version
int account when processing the input json into pg_statistic rows.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

While the statistics are applied transactionally, the changes to
pg_class (reltuples and relpages) are not. This decision was made
to avoid bloat of pg_class and is in line with the behavior of VACUUM.

Currently the function supports two boolean flags for checking the
validity of the imported data. The flag validate initiates a battery
of validation tests to ensure that all sub-objects (types, operators,
collatons, attributes, statistics) have no duplicate values. The flag
require_match_oids verifies the oids resolved in the new statistics rows
match the oids specified in the json. Setting this flag makes sense
during a binary upgrade, but not a restore.

This function also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |    6 +-
 src/include/statistics/statistics.h           |    2 +
 src/include/statistics/statistics_internal.h  |   28 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1346 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  530 +++++++
 src/test/regress/parallel_schedule            |    2 +-
 src/test/regress/sql/stats_export_import.sql  |  499 ++++++
 doc/src/sgml/func.sgml                        |   65 +
 10 files changed, 2479 insertions(+), 3 deletions(-)
 create mode 100644 src/include/statistics/statistics_internal.h
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 9c120fc2b7..0e48c08566 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -8825,7 +8825,11 @@
 { oid => '3813', descr => 'generate XML text node',
   proname => 'xmltext', proisstrict => 't', prorettype => 'xml',
   proargtypes => 'text', prosrc => 'xmltext' },
-
+{ oid => '3814',
+  descr => 'statistics: import to relation',
+  proname => 'pg_import_rel_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_rel_stats' },
 { oid => '2923', descr => 'map table contents to XML',
   proname => 'table_to_xml', procost => '100', provolatile => 's',
   proparallel => 'r', prorettype => 'xml',
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..0c3867f918 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_import_rel_stats(PG_FUNCTION_ARGS);
+
 #endif							/* STATISTICS_H */
diff --git a/src/include/statistics/statistics_internal.h b/src/include/statistics/statistics_internal.h
new file mode 100644
index 0000000000..e61a64d8b7
--- /dev/null
+++ b/src/include/statistics/statistics_internal.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics_internal.h
+ *	  Extended statistics and selectivity estimation functions.
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/statistics/statistics_internal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef STATISTICS_INTERNAL_H
+#define STATISTICS_INTERNAL_H
+
+#include "nodes/pathnodes.h"
+
+extern void validate_no_duplicates(Datum document, bool document_null,
+								   const char *sql, const char *docname,
+								   const char *colname);
+
+extern void validate_exported_types(Datum types, bool types_null);
+extern void validate_exported_collations(Datum collations, bool collations_null);
+extern void validate_exported_operators(Datum operators, bool operators_null);
+extern void validate_exported_attributes(Datum attributes, bool attributes_null);
+extern void validate_exported_statistics(Datum statistics, bool statistics_null);
+
+#endif							/* STATISTICS_INTERNAL_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..90d117c0d6
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1346 @@
+/*-------------------------------------------------------------------------
+ *
+ * statistics.c
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "executor/spi.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "statistics/statistics_internal.h"
+#include "utils/builtins.h"
+#include "utils/rel.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Struct to capture only the infomration we need from
+ * get_attrinfo
+ */
+typedef struct {
+	Oid		typid;
+	int32	typmod;
+	Oid		collid;
+	Oid 	eqopr;
+	Oid 	ltopr;
+	Oid		basetypid;
+	Oid 	baseeqopr;
+	Oid 	baseltopr;
+} AttrInfo;
+
+
+/*
+ * Generate AttrInfo entries for each attribute in the relation.
+ * This data is a small subset of what VacAttrStats collects,
+ * and we leverage VacAttrStats to stay compatible with what
+ * do_analyze() does.
+ */
+static AttrInfo *
+get_attrinfo(Relation rel)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	bool		has_index_exprs = false;
+	ListCell   *indexpr_item = NULL;
+	AttrInfo   *res = palloc0(natts * sizeof(AttrInfo));
+	int			i;
+
+	/*
+	 * If this relation is an index and that index has expressions in
+	 * it, then we will need to keep the list of remaining expressions
+	 * aligned with the attributes as we iterate over them, whether or
+	 * not those attributes have statistics to import.
+	*/
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+				|| (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+			&& (rel->rd_indexprs != NIL))
+	{
+		has_index_exprs = true;
+		indexpr_item = list_head(rel->rd_indexprs);
+	}
+
+	for (i = 0; i < natts; i++)
+	{
+		Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);
+
+		/*
+		 * If this this attribute is an expression, pop an expression off
+		 * of the list. We need to do this even if the attribute is
+		 * dropped to pop a potential expression off the list.
+		 */
+		if (has_index_exprs && (rel->rd_index->indkey.values[i] == 0))
+		{
+			Node *index_expr = NULL;
+
+			if (indexpr_item == NULL)   /* shouldn't happen */
+				elog(ERROR, "too few entries in indexprs list");
+
+			index_expr = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+			res[i].typid = exprType(index_expr);
+			res[i].typmod = exprTypmod(index_expr);
+
+			/*
+			 * If a collation has been specified for the index column, use that in
+			 * preference to anything else; but if not, fall back to whatever we
+			 * can get from the expression.
+			 */
+			if (OidIsValid(attr->attcollation))
+				res[i].collid = attr->attcollation;
+			else
+				res[i].collid = exprCollation(index_expr);
+		}
+		else
+		{
+			res[i].typid = attr->atttypid;
+			res[i].typmod = attr->atttypmod;
+			res[i].collid = attr->attcollation;
+		}
+
+		if (attr->attisdropped)
+			continue;
+
+		get_sort_group_operators(res[i].typid,
+								 false, false, false,
+								 &res[i].ltopr, &res[i].eqopr, NULL,
+								 NULL);
+
+		res[i].basetypid = get_base_element_type(res[i].typid);
+		if (res[i].basetypid == InvalidOid)
+		{
+			/* type is its own base type */
+			res[i].basetypid = res[i].typid;
+			res[i].baseltopr = res[i].ltopr;
+			res[i].baseeqopr = res[i].eqopr;
+		}
+		else
+			get_sort_group_operators(res[i].basetypid,
+									 false, false, false,
+									 &res[i].baseltopr, &res[i].baseeqopr,
+									 NULL, NULL);
+	}
+	return res;
+}
+
+/*
+ * Delete all pg_statistic entries for a relation + inheritance type
+ */
+static void
+remove_pg_statistics(Relation rel, Relation sd, bool inh)
+{
+	TupleDesc	tupdesc = RelationGetDescr(rel);
+	int			natts = tupdesc->natts;
+	int			attnum;
+
+	for (attnum = 1; attnum <= natts; attnum++)
+	{
+		HeapTuple tup = SearchSysCache3(STATRELATTINH,
+							ObjectIdGetDatum(RelationGetRelid(rel)),
+							Int16GetDatum(attnum),
+							BoolGetDatum(inh));
+
+		if (HeapTupleIsValid(tup))
+		{
+			CatalogTupleDelete(sd, &tup->t_self);
+
+			ReleaseSysCache(tup);
+		}
+	}
+}
+
+#define NULLARG(x) ((x) ? 'n' : ' ')
+
+/*
+ * Find any duplicate values in a jsonb object casted via SPI SQL
+ * into a single-key table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_no_duplicates(Datum document, bool document_null,
+					   const char *sql, const char *docname,
+					   const char *colname)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { document };
+	char	argnulls[1] = { NULLARG(document_null) };
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		char *s = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s",
+						docname, colname, (s) ? s : "NULL")));
+	}
+}
+
+/*
+ * Ensure that the "types" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_types(Datum types, bool types_null)
+{
+	const char *sql =
+		"SELECT et.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS et(oid oid, typname text, nspname text) "
+		"GROUP BY et.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(types, types_null, sql, "types", "oid");
+}
+
+/*
+ * Ensure that the "collations" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_collations(Datum collations, bool collations_null)
+{
+	const char* sql =
+		"SELECT ec.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ec(oid oid, collname text, nspname text) "
+		"GROUP BY ec.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(collations, collations_null, sql, "collations", "oid");
+}
+
+/*
+ * Ensure that the "operators" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate oid values
+ * exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_operators(Datum operators, bool operators_null)
+{
+	const char* sql =
+		"SELECT eo.oid "
+		"FROM jsonb_to_recordset($1) "
+		"     AS eo(oid oid, oprname text, nspname text) "
+		"GROUP BY eo.oid "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(operators, operators_null, sql, "operators", "oid");
+}
+
+/*
+ * Ensure that the "attributes" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate attnum
+ * values exist in the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_attributes(Datum attributes, bool attributes_null)
+{
+	const char* sql =
+		"SELECT ea.attnum "
+		"FROM jsonb_to_recordset($1) "
+		"     AS ea(attnum int2, attname text, atttypid oid, "
+		"           attcollation oid) "
+		"GROUP BY ea.attnum "
+		"HAVING COUNT(*) > 1 ";
+
+	validate_no_duplicates(attributes, attributes_null, sql, "attributes", "attnum");
+}
+
+/*
+ * Ensure that the "statistics" document is valid.
+ *
+ * Presently the only check we make is to ensure that no duplicate combinations
+ * of (staattnum, stainherit) exist within the expanded table.
+ *
+ * This function assumes a valid SPI connection.
+ */
+void
+validate_exported_statistics(Datum statistics, bool statistics_null)
+{
+	Oid		argtypes[1] = { JSONBOID };
+	Datum	args[1] = { statistics };
+	char	argnulls[1] = { NULLARG(statistics_null) };
+
+	const char *sql =
+		"SELECT s.staattnum, s.stainherit "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"GROUP BY s.staattnum, s.stainherit "
+		"HAVING COUNT(*) > 1 ";
+
+	SPITupleTable  *tuptable;
+	int				ret;
+
+	ret = SPI_execute_with_args(sql, 1, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (tuptable->numvals > 0)
+	{
+		char *s1 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 1);
+		char *s2 = SPI_getvalue(tuptable->vals[0], tuptable->tupdesc, 2);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON document \"%s\" has duplicate rows with %s = %s, %s = %s",
+						"statistics", "staattnum", (s1) ? s1 : "NULL",
+						"stainherit", (s2) ? s2 : "NULL")));
+	}
+}
+
+
+/*
+ * Transactionally import statistics for a given relation
+ * into pg_statistic.
+ *
+ * The statistics import query does not vary by server version.
+ * However, the stacollN columns will always be NULL for versions prior
+ * to v12.
+ *
+ * The query as currently written is clearly overboard, and for now serves
+ * to show what is possible in terms of comparing the exported statistics
+ * to the existing local schema. Once we have determined what types of
+ * checks are worthwhile, we can trim out unnecessary joins and columns.
+ *
+ * Analytic columns columns like dup_count serve to check the consistency
+ * and correctness of the exported data.
+ *
+ * The return value is an array of HeapTuples.
+ * The parameter ntuples is set to the number of HeapTuples returned.
+ */
+
+static HeapTuple *
+import_pg_statistics(Relation rel, Relation sd, int server_version_num,
+					 Datum types_datum, bool types_null,
+					 Datum collations_datum, bool collations_null,
+					 Datum operators_datum, bool operators_null,
+					 Datum attributes_datum, bool attributes_null,
+					 Datum statistics_datum, bool statistics_null,
+					 bool require_match_oids, int *ntuples)
+{
+
+#define PGS_NARGS 6
+
+	Oid			argtypes[PGS_NARGS] = {
+					JSONBOID, JSONBOID, JSONBOID, JSONBOID, JSONBOID, OIDOID };
+	Datum		args[PGS_NARGS] = {
+					types_datum, collations_datum, operators_datum,
+					attributes_datum, statistics_datum,
+					ObjectIdGetDatum(RelationGetRelid(rel)) };
+	char		argnulls[PGS_NARGS] = {
+					NULLARG(types_null), NULLARG(collations_null),
+					NULLARG(operators_null), NULLARG(attributes_null),
+					NULLARG(statistics_null), NULLARG(false) };
+
+	/*
+	 * This query is currently in kitchen-sink mode, and it can be trimmed down
+	 * to eliminate any columns not needed for output or validation once
+	 * all requirements are settled.
+	 */
+	const char *sql =
+		"WITH exported_types AS ( "
+		"    SELECT et.* "
+		"    FROM jsonb_to_recordset($1) "
+		"        AS et(oid oid, typname text, nspname text) "
+		"), "
+		"exported_collations AS ( "
+		"    SELECT ec.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS ec(oid oid, collname text, nspname text) "
+		"), "
+		"exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($3) "
+		"        AS eo(oid oid, oprname text, nspname text) "
+		"), "
+		"exported_attributes AS ( "
+		"    SELECT ea.* "
+		"    FROM jsonb_to_recordset($4) "
+		"        AS ea(attnum int2, attname text, atttypid oid, "
+		"              attcollation oid) "
+		"), "
+		"exported_statistics AS ( "
+		"    SELECT s.* "
+		"    FROM jsonb_to_recordset($5) "
+		"        AS s(staattnum integer, "
+		"             stainherit boolean, "
+		"             stanullfrac float4, "
+		"             stawidth integer, "
+		"             stadistinct float4, "
+		"             stakind1 int2, "
+		"             stakind2 int2, "
+		"             stakind3 int2, "
+		"             stakind4 int2, "
+		"             stakind5 int2, "
+		"             staop1 oid, "
+		"             staop2 oid, "
+		"             staop3 oid, "
+		"             staop4 oid, "
+		"             staop5 oid, "
+		"             stacoll1 oid, "
+		"             stacoll2 oid, "
+		"             stacoll3 oid, "
+		"             stacoll4 oid, "
+		"             stacoll5 oid, "
+		"             stanumbers1 float4[], "
+		"             stanumbers2 float4[], "
+		"             stanumbers3 float4[], "
+		"             stanumbers4 float4[], "
+		"             stanumbers5 float4[], "
+		"             stavalues1 text, "
+		"             stavalues2 text, "
+		"             stavalues3 text, "
+		"             stavalues4 text, "
+		"             stavalues5 text) "
+		") "
+		"SELECT pga.attnum, pga.attname, pga.atttypid, pga.atttypmod, "
+		"       pga.attcollation, pgat.typname, "
+		"       pgatn.nspname AS typschema, pgac.collname, "
+		"       ea.attnum AS exp_attnum, ea.atttypid AS exp_atttypid, "
+		"       ea.attcollation AS exp_attcollation, "
+		"       et.typname AS exp_typname, et.nspname AS exp_typschema, "
+		"       ec.collname AS exp_collname, ec.nspname AS exp_collschema, "
+		"       es.stainherit, es.stanullfrac, es.stawidth, es.stadistinct, "
+		"       es.stakind1, es.stakind2, es.stakind3, es.stakind4, "
+		"       es.stakind5, "
+		"       es.staop1 AS exp_staop1, es.staop2 AS exp_staop2, "
+		"       es.staop3 AS exp_staop3, es.staop4 AS exp_staop4, "
+		"       es.staop5 AS exp_staop5, "
+		"       es.stacoll1 AS exp_staop1, es.stacoll2 AS exp_staop2, "
+		"       es.stacoll3 AS exp_staop3, es.stacoll4 AS exp_staop4, "
+		"       es.stacoll5 AS exp_staop5, "
+		"       es.stanumbers1, es.stanumbers2, es.stanumbers3, "
+		"       es.stanumbers4, es.stanumbers5, "
+		"       es.stavalues1, es.stavalues2, es.stavalues3, es.stavalues4, "
+		"       es.stavalues5, "
+		"       eo1.oprname AS exp_oprname1, "
+		"       eo2.oprname AS exp_oprname2, "
+		"       eo3.oprname AS exp_oprname3, "
+		"       eo4.oprname AS exp_oprname4, "
+		"       eo5.oprname AS exp_oprname5, "
+		"       coalesce(io1.oid, 0) AS staop1, "
+		"       coalesce(io2.oid, 0) AS staop2, "
+		"       coalesce(io3.oid, 0) AS staop3, "
+		"       coalesce(io4.oid, 0) AS staop4, "
+		"       coalesce(io5.oid, 0) AS staop5, "
+		"       coalesce(ic1.oid, 0) AS stacoll1, "
+		"       coalesce(ic2.oid, 0) AS stacoll2, "
+		"       coalesce(ic3.oid, 0) AS stacoll3, "
+		"       coalesce(ic4.oid, 0) AS stacoll4, "
+		"       coalesce(ic5.oid, 0) AS stacoll5, "
+		"       (pga.attname IS DISTINCT FROM ea.attname) AS attname_miss, "
+		"       (ea.attnum IS DISTINCT FROM es.staattnum) AS staattnum_miss, "
+		"       COUNT(*) OVER (PARTITION BY pga.attnum, "
+		"                                   es.stainherit) AS dup_count "
+		"FROM pg_attribute AS pga "
+		"JOIN pg_type AS pgat ON pgat.oid = pga.atttypid "
+		"JOIN pg_namespace AS pgatn ON pgatn.oid = pgat.typnamespace "
+		"LEFT JOIN pg_collation AS pgac ON pgac.oid = pga.attcollation "
+		"LEFT JOIN exported_attributes AS ea ON ea.attname = pga.attname "
+		"LEFT JOIN exported_statistics AS es ON es.staattnum = ea.attnum "
+		"LEFT JOIN exported_types AS et ON et.oid = ea.atttypid "
+		"LEFT JOIN exported_collations AS ec ON ec.oid = ea.attcollation "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = es.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = es.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = es.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = es.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = es.staop5 "
+		"LEFT JOIN exported_collations AS ec1 ON ec1.oid = es.stacoll1 "
+		"LEFT JOIN exported_collations AS ec2 ON ec2.oid = es.stacoll2 "
+		"LEFT JOIN exported_collations AS ec3 ON ec3.oid = es.stacoll3 "
+		"LEFT JOIN exported_collations AS ec4 ON ec4.oid = es.stacoll4 "
+		"LEFT JOIN exported_collations AS ec5 ON ec5.oid = es.stacoll5 "
+		"LEFT JOIN pg_namespace AS ion1 ON ion1.nspname = eo1.nspname "
+		"LEFT JOIN pg_namespace AS ion2 ON ion2.nspname = eo2.nspname "
+		"LEFT JOIN pg_namespace AS ion3 ON ion3.nspname = eo3.nspname "
+		"LEFT JOIN pg_namespace AS ion4 ON ion4.nspname = eo4.nspname "
+		"LEFT JOIN pg_namespace AS ion5 ON ion5.nspname = eo5.nspname "
+		"LEFT JOIN pg_namespace AS icn1 ON icn1.nspname = ec1.nspname "
+		"LEFT JOIN pg_namespace AS icn2 ON icn2.nspname = ec2.nspname "
+		"LEFT JOIN pg_namespace AS icn3 ON icn3.nspname = ec3.nspname "
+		"LEFT JOIN pg_namespace AS icn4 ON icn4.nspname = ec4.nspname "
+		"LEFT JOIN pg_namespace AS icn5 ON icn5.nspname = ec5.nspname "
+		"LEFT JOIN pg_operator AS io1 ON io1.oprnamespace = ion1.oid "
+		"    AND io1.oprname = eo1.oprname "
+		"    AND io1.oprleft = pga.atttypid "
+		"    AND io1.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io2 ON io2.oprnamespace = ion2.oid "
+		"    AND io2.oprname = eo2.oprname "
+		"    AND io2.oprleft = pga.atttypid "
+		"    AND io2.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io3 ON io3.oprnamespace = ion3.oid "
+		"    AND io3.oprname = eo3.oprname "
+		"    AND io3.oprleft = pga.atttypid "
+		"    AND io3.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io4 ON io4.oprnamespace = ion4.oid "
+		"    AND io4.oprname = eo4.oprname "
+		"    AND io4.oprleft = pga.atttypid "
+		"    AND io4.oprright = pga.atttypid "
+		"LEFT JOIN pg_operator AS io5 ON io5.oprnamespace = ion5.oid "
+		"    AND io5.oprname = eo5.oprname "
+		"    AND io5.oprleft = pga.atttypid "
+		"    AND io5.oprright = pga.atttypid "
+		"LEFT JOIN pg_collation as ic1 "
+		"   ON ic1.collnamespace = icn1.oid AND ic1.collname = ec1.collname "
+		"LEFT JOIN pg_collation as ic2 "
+		"   ON ic2.collnamespace = icn2.oid AND ic2.collname = ec2.collname "
+		"LEFT JOIN pg_collation as ic3 "
+		"   ON ic3.collnamespace = icn3.oid AND ic3.collname = ec3.collname "
+		"LEFT JOIN pg_collation as ic4 "
+		"   ON ic4.collnamespace = icn4.oid AND ic4.collname = ec4.collname "
+		"LEFT JOIN pg_collation as ic5 "
+		"   ON ic5.collnamespace = icn5.oid AND ic5.collname = ec5.collname "
+		"WHERE pga.attrelid = $6 "
+		"AND pga.attnum > 0 "
+		"ORDER BY pga.attnum, coalesce(es.stainherit, false)";
+
+	/*
+	 * Columns with names containing _EXP_ are values that come from exported
+	 * json data and therefore should not be directly imported into
+	 * pg_statistic. Those values were joined to current catalog values to
+	 * derive the proper value to import, and the column is exposed mostly
+	 * for validation purposes.
+	 */
+	enum
+	{
+		PGS_ATTNUM = 0,
+		PGS_ATTNAME,
+		PGS_ATTTYPID,
+		PGS_ATTTYPMOD,
+		PGS_ATTCOLLATION,
+		PGS_TYPNAME,
+		PGS_TYPSCHEMA,
+		PGS_COLLNAME,
+		PGS_EXP_ATTNUM,
+		PGS_EXP_ATTTYPID,
+		PGS_EXP_ATTCOLLATION,
+		PGS_EXP_TYPNAME,
+		PGS_EXP_TYPSCHEMA,
+		PGS_EXP_COLLNAME,
+		PGS_EXP_COLLSCHEMA,
+		PGS_STAINHERIT,
+		PGS_STANULLFRAC,
+		PGS_STAWIDTH,
+		PGS_STADISTINCT,
+		PGS_STAKIND1,
+		PGS_STAKIND2,
+		PGS_STAKIND3,
+		PGS_STAKIND4,
+		PGS_STAKIND5,
+		PGS_EXP_STAOP1,
+		PGS_EXP_STAOP2,
+		PGS_EXP_STAOP3,
+		PGS_EXP_STAOP4,
+		PGS_EXP_STAOP5,
+		PGS_EXP_STACOLL1,
+		PGS_EXP_STACOLL2,
+		PGS_EXP_STACOLL3,
+		PGS_EXP_STACOLL4,
+		PGS_EXP_STACOLL5,
+		PGS_STANUMBERS1,
+		PGS_STANUMBERS2,
+		PGS_STANUMBERS3,
+		PGS_STANUMBERS4,
+		PGS_STANUMBERS5,
+		PGS_STAVALUES1,
+		PGS_STAVALUES2,
+		PGS_STAVALUES3,
+		PGS_STAVALUES4,
+		PGS_STAVALUES5,
+		PGS_EXP_OPRNAME1,
+		PGS_EXP_OPRNAME2,
+		PGS_EXP_OPRNAME3,
+		PGS_EXP_OPRNAME4,
+		PGS_EXP_OPRNAME5,
+		PGS_STAOP1,
+		PGS_STAOP2,
+		PGS_STAOP3,
+		PGS_STAOP4,
+		PGS_STAOP5,
+		PGS_STACOLL1,
+		PGS_STACOLL2,
+		PGS_STACOLL3,
+		PGS_STACOLL4,
+		PGS_STACOLL5,
+		PGS_ATTNAME_MISS,
+		PGS_STAATTNUM_MISS,
+		PGS_DUP_COUNT,
+		NUM_PGS_COLS
+	};
+
+	AttrInfo	*relattrinfo = get_attrinfo(rel);
+	AttrInfo	*attrinfo;
+
+	int		ret;
+	int		i;
+	int		tupctr = 0;
+
+	SPITupleTable  *tuptable;
+	HeapTuple	   *rettuples;
+
+	ret = SPI_execute_with_args(sql, PGS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	rettuples = palloc0(sizeof(HeapTuple) * tuptable->numvals);
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum		pgs_datums[NUM_PGS_COLS];
+		bool		pgs_nulls[NUM_PGS_COLS];
+
+		Datum		values[Natts_pg_statistic] = { 0 };
+		bool		nulls[Natts_pg_statistic] = { false };
+
+		int			dup_count;
+		AttrNumber	attnum;
+		char	   *attname;
+		bool		stainherit;
+		char	   *inhstr;
+		AttrNumber	exported_attnum;
+		FmgrInfo	finfo;
+		int			k;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, pgs_datums,
+						  pgs_nulls);
+
+		/*
+		 * Check all the columns that cannot plausibly be null regardless of
+		 * json data quality
+		 */
+		Assert(!pgs_nulls[PGS_ATTNUM]);
+		Assert(!pgs_nulls[PGS_ATTNAME]);
+		Assert(!pgs_nulls[PGS_ATTTYPID]);
+		Assert(!pgs_nulls[PGS_ATTTYPMOD]);
+		Assert(!pgs_nulls[PGS_ATTCOLLATION]);
+		Assert(!pgs_nulls[PGS_TYPNAME]);
+		Assert(!pgs_nulls[PGS_DUP_COUNT]);
+		Assert(!pgs_nulls[PGS_ATTNAME_MISS]);
+		Assert(!pgs_nulls[PGS_STAATTNUM_MISS]);
+
+		attnum = DatumGetInt16(pgs_datums[PGS_ATTNUM]);
+		attname = NameStr(*(DatumGetName(pgs_datums[PGS_ATTNAME])));
+		attrinfo = &relattrinfo[attnum - 1];
+
+		fmgr_info(F_ARRAY_IN, &finfo);
+
+		if (pgs_nulls[PGS_STAINHERIT])
+		{
+			stainherit = false;
+			inhstr = "NULL";
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAINHERIT]))
+		{
+			stainherit = true;
+			inhstr = "true";
+		}
+		else
+		{
+			stainherit = false;
+			inhstr = "false";
+		}
+
+		/*
+		 * Any duplicates would be a cache collision and a sign that the
+		 * import json is broken.
+		 */
+		dup_count = DatumGetInt32(pgs_datums[PGS_DUP_COUNT]);
+		if (dup_count != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Attribute duplicate count %d on attnum %d attname %s stainherit %s",
+							dup_count, attnum, attname, stainherit ? "t" : "f")));
+		else if (DatumGetBool(pgs_datums[PGS_ATTNAME_MISS]))
+		{
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported attribute with name \"%s\" found.", attname)));
+			/* Do not generate a tuple */
+			continue;
+		}
+		else if (DatumGetBool(pgs_datums[PGS_STAATTNUM_MISS]))
+		{
+			if (require_match_oids)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("No exported statistic found for exported attribute \"%s\" found.",
+								attname)));
+			/* Do not generate a tuple */
+			continue;
+		}
+
+		exported_attnum = DatumGetInt16(pgs_datums[PGS_EXP_ATTNUM]);
+
+		/* Validate that the data types either match by oid or by name */
+		if (require_match_oids)
+		{
+			Oid	export_typoid = DatumGetObjectId(pgs_datums[PGS_EXP_ATTTYPID]);
+			Oid	catalog_typoid = DatumGetObjectId(pgs_datums[PGS_ATTTYPID]);
+
+			if (export_typoid != catalog_typoid)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d expects typoid %u but typoid %u imported",
+								attnum, catalog_typoid, export_typoid)));
+		}
+		else
+		{
+			char   *local_typename = NameStr(*(DatumGetName(pgs_datums[PGS_TYPNAME])));
+			char   *local_typeschema = NameStr(*(DatumGetName(pgs_datums[PGS_TYPSCHEMA])));
+
+			char   *imported_typename;
+			char   *imported_typeschema;
+					
+
+			if (pgs_nulls[PGS_EXP_TYPNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d has typname %s but imported typname is NULL",
+								attnum, local_typename)));
+
+			if (pgs_nulls[PGS_EXP_TYPSCHEMA])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d has typname %s but imported type schema is NULL",
+								attnum, local_typename)));
+
+			imported_typename = TextDatumGetCString(pgs_datums[PGS_EXP_TYPNAME]);
+			imported_typeschema = TextDatumGetCString(pgs_datums[PGS_EXP_TYPSCHEMA]);
+
+			if ((strcmp(local_typename, imported_typename) != 0) ||
+			    (strcmp(local_typeschema, imported_typeschema) != 0))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Attribute %d has type %s.%s but imported type is %s.%s",
+								attnum, local_typeschema, local_typename,
+								imported_typeschema, imported_typename)));
+
+			pfree(imported_typename);
+			pfree(imported_typeschema);
+		}
+
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
+		values[Anum_pg_statistic_staattnum - 1] = pgs_datums[PGS_ATTNUM];
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(stainherit);
+
+		/*
+		 * Any nulls here will fail the when it is written to pg_statistic
+		 * but that error message is as good as any we could create.
+		 */
+		if (pgs_nulls[PGS_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stanullfrac")));
+
+		if (pgs_nulls[PGS_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stawidth")));
+
+		if (pgs_nulls[PGS_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s",
+							exported_attnum, inhstr, "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = pgs_datums[PGS_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = pgs_datums[PGS_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = pgs_datums[PGS_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind;
+			Oid		op;
+
+			/*
+			 * stakindN
+			 *
+			 * We can't match order of stakinds from VacAttrStats because which
+			 * entries appear varies by the data in the table.
+			 *
+			 * The stakindN values assigned during ANALYZE will vary by the
+			 * amount and quality of the data sampled. As such, there is no
+			 * fixed set of kinds to match against for any one slot.
+			 *
+			 * Any NULL stakindN values will cause the row to fail.
+			 *
+			 */
+			if (pgs_nulls[PGS_STAKIND1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stakind", k+1)));
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = pgs_datums[PGS_STAKIND1 + k];
+			kind = DatumGetInt16(pgs_datums[PGS_STAKIND1 + k]);
+
+			/*
+			 * staopN
+			 *
+			 * We cannot resolve the exported operator back to a local Oid because
+			 * that cannot be looked up directly in the catalog, so we have to
+			 * instead look at the exported operator name, choose the op from
+			 * the typecache, and then if we're requiring matching oids we can
+			 * compare that to the exported oid.
+			 *
+			 * A comparison of operator names isn't interesting, as they're either
+			 * < or = deterministically chosen by the stakindN.
+			 */
+			/* Possibly validate operator must be OidIsValid when stakindN <> 0 */
+			if (pgs_nulls[PGS_EXP_OPRNAME1 + k])
+				op = InvalidOid;
+			else
+			{
+				char   *exp_oprname;
+
+				exp_oprname = TextDatumGetCString(pgs_datums[PGS_EXP_OPRNAME1 + k]);
+				if (strcmp(exp_oprname, "=") == 0)
+				{
+					/*
+					 * MCELEM stat arrays are of the same type as the
+					 * array base element type and are eqopr
+					 */
+					if ((kind == STATISTIC_KIND_MCELEM) ||
+						(kind == STATISTIC_KIND_DECHIST))
+						op = attrinfo->baseeqopr;
+					else
+						op = attrinfo->eqopr;
+				}
+				else if (strcmp(exp_oprname, "<") == 0)
+					op = attrinfo->ltopr;
+				else
+					op = InvalidOid;
+				pfree(exp_oprname);
+			}
+
+			if (require_match_oids)
+			{
+				if (pgs_nulls[PGS_EXP_STAOP1 + k])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d staop%d kind %d expects Oid %u but NULL imported",
+									attnum, k+1, kind,  op)));
+				else
+				{
+					Oid	export_op = DatumGetObjectId(pgs_datums[PGS_EXP_STAOP1 + k]);
+					if (export_op != op)
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("Attribute %d staop%d kind %d expects Oid %u but Oid %u imported",
+										attnum, k+1, kind,  op, export_op)));
+				}
+			}
+			values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(op);
+
+			/* Any NULL stacollN will fail the row */
+			if (pgs_nulls[PGS_STACOLL1 + k])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Imported Statistics Attribute %d stainherit %s cannot have NULL %s%d",
+								exported_attnum, inhstr, "stacoll", k+1)));
+			values[Anum_pg_statistic_stacoll1 - 1 + k] = pgs_datums[PGS_STACOLL1 + k];
+
+			if (require_match_oids)
+			{
+				Oid	export_coll = DatumGetObjectId(pgs_datums[PGS_EXP_STACOLL1 + k]);
+				Oid	import_coll = DatumGetObjectId(pgs_datums[PGS_STACOLL1 + k]);
+
+				if (export_coll != import_coll)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("Attribute %d stacoll%d expects Oid %u but Oid %u imported",
+									attnum, k+1, export_coll, import_coll)));
+			}
+
+			/* stanumbersN - the import query did the required type coercion. */
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_datums[PGS_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				pgs_nulls[PGS_STANUMBERS1 + k];
+
+			/* stavaluesN */
+			if (pgs_nulls[PGS_STAVALUES1 + k])
+			{
+				nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			}
+			else
+			{
+				char    *s = TextDatumGetCString(pgs_datums[PGS_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(attrinfo->basetypid),
+								  Int32GetDatum(attrinfo->typmod));
+
+				pfree(s);
+			}
+		}
+
+		/* Add valid tuple to the list */
+		rettuples[tupctr++] = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+	}
+
+	pfree(relattrinfo);
+	*ntuples = tupctr;
+	return rettuples;
+}
+
+/*
+ * Import statistics for a given relation.
+ *
+ * The first parameter is the oid of the target relation for the statistics.
+ * The oid must be valid.
+ *
+ * The second parameter is the JSON object that contains the statistics to be
+ * imported, as well as information about types, collations, operators, and
+ * attributes associated with those statistics.
+ *
+ * This JSON object is decoded in stages. The first stage extracts the
+ * top-level keys but does not drill down further. Among those keys will
+ * be server_version_num, and the value of key determines which queries are
+ * used to reconstruct the statistics that will be inserted into pg_statistic.
+ *
+ * The actual decoding of statistics, and the catalog data that was exported
+ * alongside those statitics, happens in import_pg_statistics().
+
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   "reltuples": number, -- pg_class.reltuples
+ *   "relpages": number, -- pg_class.relpages
+ *   "types": [
+ *         -- export of all pg_type referenced in this json doc
+ *         {
+ *            "oid": number, -- pg_type.oid
+ *            "typname": string, -- pg_type.typname
+ *            "nspname": string -- schema name for the pg_type
+ *         }
+ *      ],
+ *   "collations": [
+ *         -- export all pg_collation reference in this json doc
+ *         {
+ *            "oid": number, -- pg_collation.oid
+ *            "collname": string, -- pg_collation.collname
+ *            "nspname": string -- schema name for the pg_collation
+ *         }
+ *      ],
+ *   "operators": [
+ *         -- export all pg_operator reference in this json doc
+ *         {
+ *            "oid": number, -- pg_operator.oid
+ *            "collname": string, -- pg_oprname
+ *            "nspname": string -- schema name for the pg_operator
+ *         }
+ *      ],
+ *   "attributes": [
+ *         -- export all pg_attribute for the exported relation
+ *         {
+ *            "attnum": number, -- pg_attribute.attnum
+ *            "attname": string, -- pg_attribute.attname
+ *            "atttypid": number, -- pg_attribute.atttypid
+ *            "attcollation": number -- pg_attribute.attcollation
+ *         }
+ *      ],
+ *   "statistics": [
+ *         -- export all pg_statistic for the exported relation
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *      ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+
+ */
+Datum
+pg_import_rel_stats(PG_FUNCTION_ARGS)
+{
+	Oid		relid;
+	bool	validate;
+	bool	require_match_oids;
+
+	const char *sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    relname text, "
+		"    nspname text, "
+		"    reltuples float4,"
+		"    relpages int4, "
+		"    types jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    attributes jsonb, "
+		"    statistics jsonb) ";
+
+	enum
+	{
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_RELTUPLES,
+		BQ_RELPAGES,
+		BQ_TYPES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_ATTRIBUTES,
+		BQ_STATISTICS,
+		NUM_BQ_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid			argtypes[BQ_NARGS] = { JSONBOID };
+	Datum		args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Datum	datums[NUM_BQ_COLS];
+	bool	nulls[NUM_BQ_COLS];
+
+	int32	server_version_num;
+	int32	current_version_num;
+
+	Relation	rel;
+	Relation	sd;
+	HeapTuple  *sdtuples;
+	int			nsdtuples;
+	int			i;
+
+	CatalogIndexState	indstate = NULL;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("relation cannot be NULL")));
+	relid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(sql, BQ_NARGS, argtypes, args, NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("statistic export JSON should return only one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, datums, nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	if (require_match_oids)
+	{
+		char   *curr_relname = SPI_getrelname(rel);
+		char   *curr_nspname = SPI_getnspname(rel);
+		char   *import_relname;
+		char   *import_nspname;
+
+		if (nulls[BQ_RELNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name must match relation name, but is null")));
+
+		if (nulls[BQ_NSPNAME])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name must match schema name, but is null")));
+
+		import_relname = TextDatumGetCString(datums[BQ_RELNAME]);
+		import_nspname = TextDatumGetCString(datums[BQ_NSPNAME]);
+
+		if (strcmp(import_relname, curr_relname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Name (%s) must match relation name (%s), but does not",
+							import_relname, curr_relname)));
+
+		if (strcmp(import_nspname, curr_nspname) != 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported Relation Schema Name (%s) must match schema name (%s), but does not",
+							import_nspname, curr_nspname)));
+
+		pfree(curr_relname);
+		pfree(curr_nspname);
+		pfree(import_relname);
+		pfree(import_nspname);
+	}
+
+	/*
+	 * validations
+	 *
+	 * Potential future validations:
+	 *
+	 *  * all attributes.atttypid values are represented in "types"
+	 *  * all attributes.attcollation values are represented in "types"
+	 *  * attributes.attname is of acceptable length
+	 *  * all non-invalid statistics.opN values are represented in "operators"
+	 *  * all non-invalid statistics.collN values are represented in "collations"
+	 *  * statistincs.kindN values in 0-7
+	 *  * statistics.stanullfrac in range
+	 *  * statistics.stawidth in range
+	 *  * statistics.ndistinct in rage
+	 *
+	 */
+	if (validate)
+	{
+		validate_exported_types(datums[BQ_TYPES], nulls[BQ_TYPES]);
+		validate_exported_collations(datums[BQ_COLLATIONS], nulls[BQ_COLLATIONS]);
+		validate_exported_operators(datums[BQ_OPERATORS], nulls[BQ_OPERATORS]);
+		validate_exported_attributes(datums[BQ_ATTRIBUTES], nulls[BQ_ATTRIBUTES]);
+		validate_exported_statistics(datums[BQ_STATISTICS], nulls[BQ_STATISTICS]);
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	sdtuples = import_pg_statistics(rel, sd, server_version_num,
+									datums[BQ_TYPES], nulls[BQ_TYPES],
+									datums[BQ_COLLATIONS], nulls[BQ_COLLATIONS],
+									datums[BQ_OPERATORS], nulls[BQ_OPERATORS],
+									datums[BQ_ATTRIBUTES], nulls[BQ_ATTRIBUTES],
+									datums[BQ_STATISTICS], nulls[BQ_STATISTICS],
+									require_match_oids, &nsdtuples);
+
+	/* Open index information when we know we need it */
+	indstate = CatalogOpenIndexes(sd);
+
+	/* Delete existing pg_statistic rows for relation to avoid collisions */
+	remove_pg_statistics(rel, sd, false);
+	if (RELKIND_HAS_PARTITIONS(rel->rd_rel->relkind))
+		remove_pg_statistics(rel, sd, true);
+
+	for (i = 0; i < nsdtuples; i++)
+	{
+		CatalogTupleInsertWithInfo(sd, sdtuples[i], indstate);
+		heap_freetuple(sdtuples[i]);
+	}
+
+	CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+	pfree(sdtuples);
+
+	/*
+	 * Update pg_class tuple directly (non-transactionally, same as
+	 * is done in do_analyze().
+	 *
+	 * Only modify pg_class row if changes are to be made
+	 */
+	if (!nulls[BQ_RELTUPLES] || !nulls[BQ_RELPAGES])
+	{
+		Relation		pg_class_rel;
+		HeapTuple		ctup;
+		Form_pg_class	pgcform;
+
+		/*
+		 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+		 * other stat-setting operation can run on it concurrently.
+		 */
+		pg_class_rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+		/* leave if relation could not be opened or locked */
+		if (!pg_class_rel)
+			PG_RETURN_BOOL(false);
+
+		ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+		if (!HeapTupleIsValid(ctup))
+			elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+				 relid);
+
+		pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+		/* leave un-set values alone */
+		if (!nulls[BQ_RELTUPLES])
+			pgcform->reltuples = DatumGetFloat4(datums[BQ_RELTUPLES]);
+
+		if(!nulls[BQ_RELPAGES])
+			pgcform->relpages = DatumGetInt32(datums[BQ_RELPAGES]);
+
+		heap_inplace_update(pg_class_rel, ctup);
+		table_close(pg_class_rel, ShareUpdateExclusiveLock);
+	}
+
+	relation_close(rel, NoLock);
+
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..5ab51c5aa0
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,530 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+ count 
+-------
+     5
+(1 row)
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+ table_stats_json 
+------------------
+(0 rows)
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+ index_stats_json 
+------------------
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+ count 
+-------
+     0
+(1 row)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         0
+ test    |        -1
+(2 rows)
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "types" has duplicate rows with oid = 2
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "collations" has duplicate rows with oid = 1
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "operators" has duplicate rows with oid = 3
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "attributes" has duplicate rows with attnum = 4
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+ERROR:  statistic export JSON document "statistics" has duplicate rows with staattnum = 1, stainherit = f
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+ pg_import_rel_stats 
+---------------------
+ t
+(1 row)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+ relname | reltuples 
+---------+-----------
+ is_odd  |         4
+ test    |         4
+(2 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..9a80eebeec
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,499 @@
+-- set to 't' to see debug output
+\set debug f
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_capture
+AS
+SELECT  starelid,
+        staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_capture;
+
+-- Export stats
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS table_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.test'::regclass
+\gset
+
+SELECT jsonb_pretty(:'table_stats_json'::jsonb) AS table_stats_json
+WHERE :'debug'::boolean;
+
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'reltuples', r.reltuples,
+        'relpages', r.relpages,
+        'types',
+        (
+            SELECT array_agg(tr ORDER BY tr.oid)
+            FROM (
+                SELECT
+                    t.oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_type AS t
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE t.oid IN (
+                    SELECT a.atttypid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                )
+            ) AS tr
+        ),
+        'collations',
+        (
+            SELECT array_agg(cr ORDER BY cr.oid)
+            FROM (
+                SELECT
+                    c.oid,
+                    c.collname,
+                    n.nspname
+                FROM pg_collation AS c
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+                WHERE c.oid IN (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE s.starelid = r.oid
+                    )
+                ) AS cr
+        ),
+        'operators',
+        (
+            SELECT array_agg(p ORDER BY p.oid)
+            FROM (
+                SELECT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_operator AS o
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE o.oid IN (
+                    SELECT u.oid
+                    FROM pg_statistic AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.staop1, s.staop2,
+                                        s.staop3, s.staop4,
+                                        s.staop5]) AS u(opid)
+                    WHERE s.starelid = r.oid
+                    )
+            ) AS p
+        ),
+        'attributes',
+        (
+            SELECT array_agg(ar ORDER BY ar.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS ar
+        ),
+        'statistics',
+        (
+            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum)
+            FROM (
+                SELECT
+                     s.staattnum,
+                     s.stainherit,
+                     s.stanullfrac,
+                     s.stawidth,
+                     s.stadistinct,
+                     s.stakind1,
+                     s.stakind2,
+                     s.stakind3,
+                     s.stakind4,
+                     s.stakind5,
+                     s.staop1,
+                     s.staop2,
+                     s.staop3,
+                     s.staop4,
+                     s.staop5,
+                     s.stacoll1,
+                     s.stacoll2,
+                     s.stacoll3,
+                     s.stacoll4,
+                     s.stacoll5,
+                     s.stanumbers1::text AS stanumbers1,
+                     s.stanumbers2::text AS stanumbers2,
+                     s.stanumbers3::text AS stanumbers3,
+                     s.stanumbers4::text AS stanumbers4,
+                     s.stanumbers5::text AS stanumbers5,
+                     s.stavalues1::text AS stavalues1,
+                     s.stavalues2::text AS stavalues2,
+                     s.stavalues3::text AS stavalues3,
+                     s.stavalues4::text AS stavalues4,
+                     s.stavalues5::text AS stavalues5
+                FROM pg_statistic AS s
+                WHERE s.starelid = r.oid
+            ) AS sr
+        )
+    ) AS index_stats_json
+FROM pg_class AS r
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE r.oid = 'stats_export_import.is_odd'::regclass
+\gset
+
+SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
+WHERE :'debug'::boolean;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+-- Move table and index out of the way
+ALTER TABLE stats_export_import.test RENAME TO test_orig;
+ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+
+-- Create empty copy tables
+CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Verify no stats for these new tables
+SELECT COUNT(*)
+FROM pg_statistic
+WHERE starelid IN('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass);
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
+
+
+-- Test valiation
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'types',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'type1' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type2' AS typname
+                UNION ALL
+                SELECT 2 AS oid, 'type3' AS typname
+                ) AS r
+        )) AS invalid_types_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'collations',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'coll1' AS collname
+                UNION ALL
+                SELECT 1 AS oid, 'coll2' AS collname
+                UNION ALL
+                SELECT 2 AS oid, 'coll3' AS collname
+                ) AS r
+        )) AS invalid_collations_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'operators',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS oid, 'opr1' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr2' AS oprname
+                UNION ALL
+                SELECT 3 AS oid, 'opr3' AS oprname
+                ) AS r
+        )) AS invalid_operators_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'attributes',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS attnum, 'col1' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col2' AS attname
+                UNION ALL
+                SELECT 4 AS attnum, 'col3' AS attname
+                ) AS r
+        )) AS invalid_attributes_doc,
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'relname', 'test',
+        'nspname', 'stats_export_import',
+        'statistics',
+        (
+            SELECT array_agg(r)
+            FROM (
+                SELECT 1 AS staattnum, false AS stainherit
+                UNION ALL
+                SELECT 5 AS staattnum, true AS stainherit
+                UNION ALL
+                SELECT 1 AS staattnum, false AS stainherit
+                ) AS r
+        )) AS invalid_statistics_doc
+\gset
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_types_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_collations_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_operators_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_attributes_doc'::jsonb, true, true);
+
+SELECT pg_import_rel_stats('stats_export_import.test'::regclass,
+        :'invalid_statistics_doc'::jsonb, true, true);
+
+-- Import stats
+SELECT pg_import_rel_stats(
+        'stats_export_import.test'::regclass,
+        :'table_stats_json'::jsonb,
+        true,
+        true);
+
+SELECT pg_import_rel_stats(
+        'stats_export_import.is_odd'::regclass,
+        :'index_stats_json'::jsonb,
+        true,
+        true);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass);
+
+-- This should return 0 rows
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+EXCEPT
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture;
+
+SELECT relname, reltuples
+FROM pg_class
+WHERE oid IN ('stats_export_import.test'::regclass,
+              'stats_export_import.is_odd'::regclass)
+ORDER BY relname;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index cf3de80394..2be0a30d4d 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28732,6 +28732,71 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_rel_stats</primary>
+        </indexterm>
+        <function>pg_import_rel_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>relation_stats</parameter> <type>jsonb</type>, <parameter>validate</parameter> <type>bool</type>, <parameter>require_match_oids</parameter> <type>bool</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces all statistics generated by a previous
+        <command>ANALYZE</command> for the <parameter>relation</parameter>
+        with values specified in <parameter>relation_stats</parameter>.
+       </para>
+       <para>
+        Specifically, the <structname>pg_statistic</structname> rows with a
+        <structfield>statrelid</structfield> matching
+        <parameter>relation</parameter> are replaced with the values derived
+        from <parameter>relation_stats</parameter>, and the
+        <structname>pg_class</structname> entry for
+        <parameter>relation</parameter> is modified, replacing the
+        <structfield>reltuples</structfield> and
+        <structfield>relpages</structfield> with values found in
+        <parameter>relation_stats</parameter>.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function
+        could be used by <command>pg_upgrade</command> and
+        <command>pg_restore</command> to convey the statistics from the old system
+        version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>relation_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para>
+       <para>
+        If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
+        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
+        not match the values specified in <parameter>relation_json</parameter>, as would be expected
+        in a binary upgrade. These assumptions would not be true when restoring from a dump.
+       </para></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.43.2

From 3b58ce044849530868a726c2ab1b0124fca3a0a0 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 20 Feb 2024 01:12:22 -0500
Subject: [PATCH v6 2/4] Create pg_import_ext_stats().

This is the extended statistics equivalent of pg_import_rel_stats().

The most likely application of this function is to quickly apply stats
to a newly upgraded database faster than could be accomplished by
vacuumdb --analyze-in-stages.

The exported values stored in the parameter extended_stats are
compared against the existing structure in pg_statistic_ext and are
transformed into pg_statistic_ext_data rows, transactionally replacing
any pre-existing rows for that object.

The statistics applied are not locked in any way, and will be
overwritten by the next analyze, either explicit or via autovacuum.

This function also allows for tweaking of table statistics in-place,
allowing the user to simulate correlations, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |    5 +
 .../statistics/extended_stats_internal.h      |    7 +
 src/backend/statistics/dependencies.c         |  161 +++
 src/backend/statistics/extended_stats.c       | 1023 +++++++++++++++--
 src/backend/statistics/mcv.c                  |  192 ++++
 src/backend/statistics/mvdistinct.c           |  160 +++
 src/backend/statistics/statistics.c           |    3 +-
 .../regress/expected/stats_export_import.out  |  269 ++++-
 src/test/regress/sql/stats_export_import.sql  |  249 +++-
 doc/src/sgml/func.sgml                        |   28 +-
 10 files changed, 2018 insertions(+), 79 deletions(-)

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 0e48c08566..701ed3a2c9 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -6125,6 +6125,11 @@
 { oid => '9161', descr => 'adjust time to local time zone',
   proname => 'timezone', provolatile => 's', prorettype => 'timetz',
   proargtypes => 'timetz', prosrc => 'timetz_at_local' },
+{ oid => '9162',
+  descr => 'statistics: import to extended stats object',
+  proname => 'pg_import_ext_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool', proargtypes => 'oid jsonb bool bool',
+  prosrc => 'pg_import_ext_stats' },
 { oid => '2039', descr => 'hash',
   proname => 'timestamp_hash', prorettype => 'int4', proargtypes => 'timestamp',
   prosrc => 'timestamp_hash' },
diff --git a/src/include/statistics/extended_stats_internal.h b/src/include/statistics/extended_stats_internal.h
index 8eed9b338d..e325a76e63 100644
--- a/src/include/statistics/extended_stats_internal.h
+++ b/src/include/statistics/extended_stats_internal.h
@@ -70,15 +70,22 @@ typedef struct StatsBuildData
 
 
 extern MVNDistinct *statext_ndistinct_build(double totalrows, StatsBuildData *data);
+extern MVNDistinct *statext_ndistinct_import(Oid relid, Datum ndistinct,
+						bool ndististinct_null, Datum attributes,
+						bool attributes_null);
 extern bytea *statext_ndistinct_serialize(MVNDistinct *ndistinct);
 extern MVNDistinct *statext_ndistinct_deserialize(bytea *data);
 
 extern MVDependencies *statext_dependencies_build(StatsBuildData *data);
+extern MVDependencies *statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null);
 extern bytea *statext_dependencies_serialize(MVDependencies *dependencies);
 extern MVDependencies *statext_dependencies_deserialize(bytea *data);
 
 extern MCVList *statext_mcv_build(StatsBuildData *data,
 								  double totalrows, int stattarget);
+extern MCVList *statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **stats);
 extern bytea *statext_mcv_serialize(MCVList *mcvlist, VacAttrStats **stats);
 extern MCVList *statext_mcv_deserialize(bytea *data);
 
diff --git a/src/backend/statistics/dependencies.c b/src/backend/statistics/dependencies.c
index 4752b99ed5..e482eca557 100644
--- a/src/backend/statistics/dependencies.c
+++ b/src/backend/statistics/dependencies.c
@@ -18,6 +18,7 @@
 #include "catalog/pg_operator.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "nodes/nodeFuncs.h"
 #include "nodes/nodes.h"
@@ -27,6 +28,7 @@
 #include "parser/parsetree.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/bytea.h"
 #include "utils/fmgroids.h"
 #include "utils/fmgrprotos.h"
@@ -1829,3 +1831,162 @@ dependencies_clauselist_selectivity(PlannerInfo *root,
 
 	return s1;
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The dependencies serialization is a string that looks like
+ *       {"2 => 3": 0.258241, "1 => 2": 0.0, ...}
+ *
+ *   The integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we
+ *   match them by name.
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *
+ */
+MVDependencies *
+statext_dependencies_import(Oid relid,
+							Datum dependencies, bool dependencies_null,
+							Datum attributes, bool attributes_null)
+{
+	MVDependencies *result = NULL;
+
+#define DEPS_NARGS 3
+
+	Oid			argtypes[DEPS_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[DEPS_NARGS] = { relid, dependencies, attributes };
+	char		argnulls[DEPS_NARGS] = { ' ',
+					dependencies_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    dep.depord, "
+		"    da.depattrord, "
+		"    da.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN da.exp_attnum < 0 THEN da.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    dep.degree::float8 AS degree, "
+		"    COUNT(*) OVER (PARTITION BY dep.depord) AS num_attrs, "
+		"    MAX(dep.depord) OVER () AS num_deps "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS dep(attrs, degree, depord) "
+		"CROSS JOIN LATERAL unnest( string_to_array( "
+		"         replace(dep.attrs, ' => ', ', '), ', ')::int2[]) "
+		"     WITH ORDINALITY AS da(exp_attnum, depattrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = da.exp_attnum AND da.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY dep.depord, da.depattrord ";
+
+	enum {
+		DEPS_DEPORD = 0,
+		DEPS_DEPATTRORD,
+		DEPS_EXP_ATTNUM,
+		DEPS_EXP_ATTNAME,
+		DEPS_ATTNUM,
+		DEPS_DEGREE,
+		DEPS_NUM_ATTRS,
+		DEPS_NUM_DEPS,
+		NUM_DEPS_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				ndeps;
+	int				j = 0;
+
+	ret = SPI_execute_with_args(sql, DEPS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		ndeps = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								DEPS_NUM_DEPS+1, &isnull);
+		ndeps = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	if (ndeps == 0)
+		result = (MVDependencies *) palloc0(sizeof(MVDependencies));
+	else
+		result = (MVDependencies *) palloc0(offsetof(MVDependencies, deps)
+												   + (ndeps * sizeof(MVDependency *)));
+
+	result->magic = STATS_DEPS_MAGIC;
+	result->type = STATS_DEPS_TYPE_BASIC;
+	result->ndeps = ndeps;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum			datums[NUM_DEPS_COLS];
+		bool			nulls[NUM_DEPS_COLS];
+		int				natts;
+		int				d;
+		int				a;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[DEPS_DEPORD]);
+		d = DatumGetInt32(datums[DEPS_DEPORD]) - 1;
+		Assert(!nulls[DEPS_DEPATTRORD]);
+		a = DatumGetInt32(datums[DEPS_DEPATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New MVDependnecy */
+			Assert(!nulls[DEPS_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[DEPS_NUM_ATTRS]);
+
+			result->deps[d] = palloc0(offsetof(MVDependency, attributes)
+										+ (natts * sizeof(AttrNumber)));
+
+			result->deps[d]->nattributes = natts;
+			Assert(!nulls[DEPS_DEGREE]);
+			result->deps[d]->degree = DatumGetFloat8(datums[DEPS_DEGREE]);
+		}
+
+		if (!nulls[DEPS_ATTNUM])
+			result->deps[d]->attributes[a] = DatumGetInt16(datums[DEPS_ATTNUM]);
+		else if (nulls[DEPS_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency exported attnum cannot be null")));
+		else if (nulls[DEPS_ATTNUM])
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[DEPS_EXP_ATTNUM]);
+
+			if (nulls[DEPS_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("Dependency has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[DEPS_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
index c5461514d8..4a86910200 100644
--- a/src/backend/statistics/extended_stats.c
+++ b/src/backend/statistics/extended_stats.c
@@ -19,12 +19,14 @@
 #include "access/detoast.h"
 #include "access/genam.h"
 #include "access/htup_details.h"
+#include "access/relation.h"
 #include "access/table.h"
 #include "catalog/indexing.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
 #include "executor/executor.h"
+#include "executor/spi.h"
 #include "commands/defrem.h"
 #include "commands/progress.h"
 #include "miscadmin.h"
@@ -32,10 +34,12 @@
 #include "optimizer/clauses.h"
 #include "optimizer/optimizer.h"
 #include "parser/parsetree.h"
+#include "parser/parse_oper.h"
 #include "pgstat.h"
 #include "postmaster/autovacuum.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "statistics/statistics_internal.h"
 #include "utils/acl.h"
 #include "utils/array.h"
 #include "utils/attoptcache.h"
@@ -418,6 +422,83 @@ statext_is_kind_built(HeapTuple htup, char type)
 	return !heap_attisnull(htup, attnum, NULL);
 }
 
+/*
+ * Create a single StatExtEntry from a fetched heap tuple
+ */
+static StatExtEntry *
+statext_create_entry(HeapTuple htup)
+{
+	StatExtEntry *entry;
+	Datum		datum;
+	bool		isnull;
+	int			i;
+	ArrayType  *arr;
+	char	   *enabled;
+	Form_pg_statistic_ext staForm;
+	List	   *exprs = NIL;
+
+	entry = palloc0(sizeof(StatExtEntry));
+	staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
+	entry->statOid = staForm->oid;
+	entry->schema = get_namespace_name(staForm->stxnamespace);
+	entry->name = pstrdup(NameStr(staForm->stxname));
+	entry->stattarget = staForm->stxstattarget;
+	for (i = 0; i < staForm->stxkeys.dim1; i++)
+	{
+		entry->columns = bms_add_member(entry->columns,
+										staForm->stxkeys.values[i]);
+	}
+
+	/* decode the stxkind char array into a list of chars */
+	datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
+								   Anum_pg_statistic_ext_stxkind);
+	arr = DatumGetArrayTypeP(datum);
+	if (ARR_NDIM(arr) != 1 ||
+		ARR_HASNULL(arr) ||
+		ARR_ELEMTYPE(arr) != CHAROID)
+		elog(ERROR, "stxkind is not a 1-D char array");
+	enabled = (char *) ARR_DATA_PTR(arr);
+	for (i = 0; i < ARR_DIMS(arr)[0]; i++)
+	{
+		Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
+			   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
+			   (enabled[i] == STATS_EXT_MCV) ||
+			   (enabled[i] == STATS_EXT_EXPRESSIONS));
+		entry->types = lappend_int(entry->types, (int) enabled[i]);
+	}
+
+	/* decode expression (if any) */
+	datum = SysCacheGetAttr(STATEXTOID, htup,
+							Anum_pg_statistic_ext_stxexprs, &isnull);
+
+	if (!isnull)
+	{
+		char	   *exprsString;
+
+		exprsString = TextDatumGetCString(datum);
+		exprs = (List *) stringToNode(exprsString);
+
+		pfree(exprsString);
+
+		/*
+		 * Run the expressions through eval_const_expressions. This is not
+		 * just an optimization, but is necessary, because the planner
+		 * will be comparing them to similarly-processed qual clauses, and
+		 * may fail to detect valid matches without this.  We must not use
+		 * canonicalize_qual, however, since these aren't qual
+		 * expressions.
+		 */
+		exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
+
+		/* May as well fix opfuncids too */
+		fix_opfuncids((Node *) exprs);
+	}
+
+	entry->exprs = exprs;
+
+	return entry;
+}
+
 /*
  * Return a list (of StatExtEntry) of statistics objects for the given relation.
  */
@@ -443,74 +524,7 @@ fetch_statentries_for_relation(Relation pg_statext, Oid relid)
 
 	while (HeapTupleIsValid(htup = systable_getnext(scan)))
 	{
-		StatExtEntry *entry;
-		Datum		datum;
-		bool		isnull;
-		int			i;
-		ArrayType  *arr;
-		char	   *enabled;
-		Form_pg_statistic_ext staForm;
-		List	   *exprs = NIL;
-
-		entry = palloc0(sizeof(StatExtEntry));
-		staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
-		entry->statOid = staForm->oid;
-		entry->schema = get_namespace_name(staForm->stxnamespace);
-		entry->name = pstrdup(NameStr(staForm->stxname));
-		entry->stattarget = staForm->stxstattarget;
-		for (i = 0; i < staForm->stxkeys.dim1; i++)
-		{
-			entry->columns = bms_add_member(entry->columns,
-											staForm->stxkeys.values[i]);
-		}
-
-		/* decode the stxkind char array into a list of chars */
-		datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
-									   Anum_pg_statistic_ext_stxkind);
-		arr = DatumGetArrayTypeP(datum);
-		if (ARR_NDIM(arr) != 1 ||
-			ARR_HASNULL(arr) ||
-			ARR_ELEMTYPE(arr) != CHAROID)
-			elog(ERROR, "stxkind is not a 1-D char array");
-		enabled = (char *) ARR_DATA_PTR(arr);
-		for (i = 0; i < ARR_DIMS(arr)[0]; i++)
-		{
-			Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
-				   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
-				   (enabled[i] == STATS_EXT_MCV) ||
-				   (enabled[i] == STATS_EXT_EXPRESSIONS));
-			entry->types = lappend_int(entry->types, (int) enabled[i]);
-		}
-
-		/* decode expression (if any) */
-		datum = SysCacheGetAttr(STATEXTOID, htup,
-								Anum_pg_statistic_ext_stxexprs, &isnull);
-
-		if (!isnull)
-		{
-			char	   *exprsString;
-
-			exprsString = TextDatumGetCString(datum);
-			exprs = (List *) stringToNode(exprsString);
-
-			pfree(exprsString);
-
-			/*
-			 * Run the expressions through eval_const_expressions. This is not
-			 * just an optimization, but is necessary, because the planner
-			 * will be comparing them to similarly-processed qual clauses, and
-			 * may fail to detect valid matches without this.  We must not use
-			 * canonicalize_qual, however, since these aren't qual
-			 * expressions.
-			 */
-			exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
-
-			/* May as well fix opfuncids too */
-			fix_opfuncids((Node *) exprs);
-		}
-
-		entry->exprs = exprs;
-
+		StatExtEntry *entry = statext_create_entry(htup);
 		result = lappend(result, entry);
 	}
 
@@ -2636,3 +2650,876 @@ make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
 
 	return result;
 }
+
+/*
+ * examine_rel_attribute -- pre-analysis of a single column
+ *
+ * Determine whether the column is analyzable; if so, create and initialize
+ * a VacAttrStats struct for it.  If not, return NULL.
+ *
+ * If index_expr isn't NULL, then we're trying to import an expression index,
+ * and index_expr is the expression tree representing the column's data.
+ */
+static VacAttrStats *
+examine_rel_attribute(Relation onerel, int attnum, Node *index_expr)
+{
+	Form_pg_attribute attr = TupleDescAttr(onerel->rd_att, attnum - 1);
+	HeapTuple		typtuple;
+	VacAttrStats   *stats;
+	int				i;
+	bool			ok;
+
+	/* Never analyze dropped columns */
+	if (attr->attisdropped)
+		return NULL;
+
+	/*
+	 * Create the VacAttrStats struct.
+	 */
+	stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
+	stats->attstattarget = 1; /* Any nonzero value */
+
+	/*
+	 * When analyzing an expression index, believe the expression tree's type
+	 * not the column datatype --- the latter might be the opckeytype storage
+	 * type of the opclass, which is not interesting for our purposes.  (Note:
+	 * if we did anything with non-expression index columns, we'd need to
+	 * figure out where to get the correct type info from, but for now that's
+	 * not a problem.)	It's not clear whether anyone will care about the
+	 * typmod, but we store that too just in case.
+	 */
+	if (index_expr)
+	{
+		stats->attrtypid = exprType(index_expr);
+		stats->attrtypmod = exprTypmod(index_expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(onerel->rd_indcollation[attnum - 1]))
+			stats->attrcollid = onerel->rd_indcollation[attnum - 1];
+		else
+			stats->attrcollid = exprCollation(index_expr);
+	}
+	else
+	{
+		stats->attrtypid = attr->atttypid;
+		stats->attrtypmod = attr->atttypmod;
+		stats->attrcollid = attr->attcollation;
+	}
+
+	typtuple = SearchSysCacheCopy1(TYPEOID,
+								   ObjectIdGetDatum(stats->attrtypid));
+	if (!HeapTupleIsValid(typtuple))
+		elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
+	stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
+	stats->anl_context = NULL;
+	stats->tupattnum = attnum;
+
+	/*
+	 * The fields describing the stats->stavalues[n] element types default to
+	 * the type of the data being analyzed, but the type-specific typanalyze
+	 * function can change them if it wants to store something else.
+	 */
+	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
+	{
+		stats->statypid[i] = stats->attrtypid;
+		stats->statyplen[i] = stats->attrtype->typlen;
+		stats->statypbyval[i] = stats->attrtype->typbyval;
+		stats->statypalign[i] = stats->attrtype->typalign;
+	}
+
+	/*
+	 * Call the type-specific typanalyze function.  If none is specified, use
+	 * std_typanalyze().
+	 */
+	if (OidIsValid(stats->attrtype->typanalyze))
+		ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
+										   PointerGetDatum(stats)));
+	else
+		ok = std_typanalyze(stats);
+
+	if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
+	{
+		heap_freetuple(typtuple);
+		pfree(stats);
+		return NULL;
+	}
+
+	return stats;
+}
+
+
+static Datum
+import_expressions(Datum stxdexpr, bool stxdexpr_null,
+				   Datum operators, bool operators_null,
+				   VacAttrStats **expr_stats, int nexprs)
+{
+
+#define EXPR_NARGS 2
+
+	Oid			argtypes[EXPR_NARGS] = { JSONBOID, JSONBOID };
+	Datum		args[EXPR_NARGS] = { stxdexpr, operators };
+	char		argnulls[EXPR_NARGS] = {
+					stxdexpr_null ? 'n' : ' ',
+					operators_null ? 'n' : ' ' };
+
+	const char *sql =
+		"WITH exported_operators AS ( "
+		"    SELECT eo.* "
+		"    FROM jsonb_to_recordset($2) "
+		"        AS eo(oid oid, oprname text) "
+		") "
+		"SELECT s.*, "
+		"       eo1.oprname AS eoprname1, "
+		"       eo2.oprname AS eoprname2, "
+		"       eo3.oprname AS eoprname3, "
+		"       eo4.oprname AS eoprname4, "
+		"       eo5.oprname AS eoprname5 "
+		"FROM jsonb_to_recordset($1) "
+		"    AS s(staattnum integer, "
+		"         stainherit boolean, "
+		"         stanullfrac float4, "
+		"         stawidth integer, "
+		"         stadistinct float4, "
+		"         stakind1 int2, "
+		"         stakind2 int2, "
+		"         stakind3 int2, "
+		"         stakind4 int2, "
+		"         stakind5 int2, "
+		"         staop1 oid, "
+		"         staop2 oid, "
+		"         staop3 oid, "
+		"         staop4 oid, "
+		"         staop5 oid, "
+		"         stacoll1 oid, "
+		"         stacoll2 oid, "
+		"         stacoll3 oid, "
+		"         stacoll4 oid, "
+		"         stacoll5 oid, "
+		"         stanumbers1 float4[], "
+		"         stanumbers2 float4[], "
+		"         stanumbers3 float4[], "
+		"         stanumbers4 float4[], "
+		"         stanumbers5 float4[], "
+		"         stavalues1 text, "
+		"         stavalues2 text, "
+		"         stavalues3 text, "
+		"         stavalues4 text, "
+		"         stavalues5 text) "
+		"LEFT JOIN exported_operators AS eo1 ON eo1.oid = s.staop1 "
+		"LEFT JOIN exported_operators AS eo2 ON eo2.oid = s.staop2 "
+		"LEFT JOIN exported_operators AS eo3 ON eo3.oid = s.staop3 "
+		"LEFT JOIN exported_operators AS eo4 ON eo4.oid = s.staop4 "
+		"LEFT JOIN exported_operators AS eo5 ON eo5.oid = s.staop5 ";
+
+	enum
+	{
+		EXPR_ATTNUM = 0,
+		EXPR_STAINHERIT,
+		EXPR_STANULLFRAC,
+		EXPR_STAWIDTH,
+		EXPR_STADISTINCT,
+		EXPR_STAKIND1,
+		EXPR_STAKIND2,
+		EXPR_STAKIND3,
+		EXPR_STAKIND4,
+		EXPR_STAKIND5,
+		EXPR_STAOP1,
+		EXPR_STAOP2,
+		EXPR_STAOP3,
+		EXPR_STAOP4,
+		EXPR_STAOP5,
+		EXPR_STACOLL1,
+		EXPR_STACOLL2,
+		EXPR_STACOLL3,
+		EXPR_STACOLL4,
+		EXPR_STACOLL5,
+		EXPR_STANUMBERS1,
+		EXPR_STANUMBERS2,
+		EXPR_STANUMBERS3,
+		EXPR_STANUMBERS4,
+		EXPR_STANUMBERS5,
+		EXPR_STAVALUES1,
+		EXPR_STAVALUES2,
+		EXPR_STAVALUES3,
+		EXPR_STAVALUES4,
+		EXPR_STAVALUES5,
+		EXPR_EOPRNAME1,
+		EXPR_EOPRNAME2,
+		EXPR_EOPRNAME3,
+		EXPR_EOPRNAME4,
+		EXPR_EOPRNAME5,
+		NUM_EXPR_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				e;
+
+	ArrayBuildState *astate = NULL;
+
+	Relation	pgsd;
+	HeapTuple	pgstup;
+	Oid			pgstypoid;
+	FmgrInfo	finfo;
+
+	pgsd = table_open(StatisticRelationId, RowExclusiveLock);
+	pgstypoid = get_rel_type_id(StatisticRelationId);
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	if (!OidIsValid(pgstypoid))
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("relation \"%s\" does not have a composite type",
+						"pg_statistic")));
+
+	ret = SPI_execute_with_args(sql, EXPR_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+
+	if (nexprs != tuptable->numvals)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export expected %d stxdexpr rows but found %lu",
+					 nexprs, tuptable->numvals)));
+
+	if (nexprs == 0)
+		astate = accumArrayResult(astate,
+								  (Datum) 0,
+								  true,
+								  pgstypoid,
+								  CurrentMemoryContext);
+
+	for (e = 0; e < nexprs; e++)
+	{
+		Datum	values[Natts_pg_statistic] = { 0 };
+		bool	nulls[Natts_pg_statistic] = { false };
+
+		Datum	rs_datums[NUM_EXPR_COLS];
+		bool	rs_nulls[NUM_EXPR_COLS];
+
+		VacAttrStats   *stats = expr_stats[e];
+
+		Oid 	basetypoid;
+		Oid		ltopr;
+		Oid 	baseltopr;
+		Oid		eqopr;
+		Oid 	baseeqopr;
+		int 	k;
+
+		/*
+		 * If if the stat is an array, then we want the base element
+		 * type. This mimics the calculation in get_attrinfo().
+		 */
+		get_sort_group_operators(stats->attrtypid,
+								 false, false, false,
+								 &ltopr, &eqopr, NULL,
+								 NULL);
+		basetypoid = get_base_element_type(stats->attrtypid);
+		if (basetypoid == InvalidOid)
+			basetypoid = stats->attrtypid;
+		get_sort_group_operators(basetypoid,
+								 false, false, false,
+								 &baseltopr, &baseeqopr, NULL,
+								 NULL);
+
+		heap_deform_tuple(tuptable->vals[e], tuptable->tupdesc,
+						  rs_datums, rs_nulls);
+
+		/* These values are not derived from either vac stats or exported stats */
+		values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
+		values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
+
+		if (rs_nulls[EXPR_STANULLFRAC])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stanullfrac")));
+
+		if (rs_nulls[EXPR_STAWIDTH])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stawidth")));
+
+		if (rs_nulls[EXPR_STADISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Imported stxdepr row cannot have NULL %s", "stadistinct")));
+
+		values[Anum_pg_statistic_stanullfrac - 1] = rs_datums[EXPR_STANULLFRAC];
+		values[Anum_pg_statistic_stawidth - 1] = rs_datums[EXPR_STAWIDTH];
+		values[Anum_pg_statistic_stadistinct - 1] = rs_datums[EXPR_STADISTINCT];
+
+		for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
+		{
+			int16	kind = 0;
+			Oid		op = InvalidOid;
+
+			if (!rs_nulls[EXPR_STAKIND1 + k])
+			{
+				kind = Int16GetDatum(rs_datums[EXPR_STAKIND1 + k]);
+
+				if (!rs_nulls[EXPR_EOPRNAME1 + k])
+				{
+					char *s = TextDatumGetCString(rs_datums[EXPR_EOPRNAME1 + k]);
+
+					if (strcmp(s, "=") == 0)
+					{
+						/*
+						 * MCELEM stat arrays are of the same type as the
+						 * array base element type and are eqopr
+						 */
+						if ((kind == STATISTIC_KIND_MCELEM) ||
+							(kind == STATISTIC_KIND_DECHIST))
+							op = baseeqopr;
+						else
+							op = eqopr;
+					}
+					else if (strcmp(s, "<") == 0)
+						op = ltopr;
+					else
+						op = InvalidOid;
+
+					pfree(s);
+				}
+			}
+
+			values[Anum_pg_statistic_stakind1 - 1 + k] = kind;
+			values[Anum_pg_statistic_staop1 - 1 + k] = op;
+
+			/* rely on vacattrstat */
+			values[Anum_pg_statistic_stacoll1 - 1 + k] =
+				ObjectIdGetDatum(stats->stacoll[k]);
+
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_datums[EXPR_STANUMBERS1 + k];
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				rs_nulls[EXPR_STANUMBERS1 + k];
+
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] =
+				rs_nulls[EXPR_STAVALUES1 + k];
+			if (rs_nulls[EXPR_STAVALUES1 + k])
+				values[Anum_pg_statistic_stavalues1 - 1 + k] = (Datum) 0;
+			else
+			{
+				char *s = TextDatumGetCString(rs_datums[EXPR_STAVALUES1 + k]);
+
+				values[Anum_pg_statistic_stavalues1 - 1 + k] =
+					FunctionCall3(&finfo, CStringGetDatum(s),
+								  ObjectIdGetDatum(basetypoid),
+								  Int32GetDatum(stats->attrtypmod));
+
+				pfree(s);
+			}
+		}
+
+		pgstup = heap_form_tuple(RelationGetDescr(pgsd), values, nulls);
+
+		astate = accumArrayResult(astate,
+								  heap_copy_tuple_as_datum(pgstup, RelationGetDescr(pgsd)),
+								  false,
+								  pgstypoid,
+								  CurrentMemoryContext);
+	}
+
+	table_close(pgsd, RowExclusiveLock);
+
+	return makeArrayResult(astate, CurrentMemoryContext);
+}
+
+/*
+ * Import statistics for a given extended statistics object.
+ *
+ * The statistics json format is:
+ *
+ * {
+ *   "server_version_num": number, -- SHOW server_version on source system
+ *   "stxoid": number, -- pg_stat_ext.stxoid
+ *   "stxname": string, -- pg_stat_ext.stxname
+ *   "stxnspname": string, -- schema name for the statistics object
+ *   "relname": string, -- pgclass.relname of the exported relation
+ *   "nspname": string, -- schema name for the exported relation
+ *   -- stxkeys cast to text to aid array_in()
+ *   "stxkeys": string, -- pg_statistic_ext.stxkind::text
+ *   -- stxndistinct and stxdndepencies only on v10-v11
+ *   "stxndistinct": string, -- pg_statistic_ext.stxndistinct::text
+ *   "stxdependencies": string, -- pg_statistic_ext.stxdependencies::text
+ *   -- data is on v12+
+ *   "data": [
+ *     {
+ *       -- stxdinherit is on v15+
+ *       "stxdinherit": bool, -- pg_statistic_ext_data.stxdinherit
+ *       -- stxdndistinct and stxddependencies are on v12+
+ *       "stxdndistinct": text, -- pg_statistic_ext_data.stxdndisinct::text
+ *       "stxddependencies": text, -- pg_statistic_ext_data.stxddepencies::text
+ *       -- stxdexpr is on v12+
+ *       "stxdmcv": [
+ *         {
+ *           "index": number,
+ *           "nulls": [bool],
+ *           "values": [text],
+ *           "frequency": number,
+ *           "base_frequency": number
+ *         }
+ *       ],
+ *       -- stxdexpr is on v14+
+ *       "stxdexpr": [
+ *         {
+ *            "staattnum": number, -- pg_statistic.staattnum
+ *            "stainherit": bool, -- pg_statistic.stainherit
+ *            "stanullfrac": number, -- pg_statistic.stanullfrac
+ *            "stawidth": number, -- pg_statistic.stawidth
+ *            "stadistinct": number, -- pg_statistic.stadistinct
+ *            "stakind1": number, -- pg_statistic.stakind1
+ *            "stakind2": number, -- pg_statistic.stakind2
+ *            "stakind3": number, -- pg_statistic.stakind3
+ *            "stakind4": number, -- pg_statistic.stakind4
+ *            "stakind5": number, -- pg_statistic.stakind5
+ *            "staop1": number, -- pg_statistic.staop1
+ *            "staop2": number, -- pg_statistic.staop2
+ *            "staop3": number, -- pg_statistic.staop3
+ *            "staop4": number, -- pg_statistic.staop4
+ *            "staop5": number, -- pg_statistic.staop5
+ *            "stacoll1": number, -- pg_statistic.stacoll1
+ *            "stacoll2": number, -- pg_statistic.stacoll2
+ *            "stacoll3": number, -- pg_statistic.stacoll3
+ *            "stacoll4": number, -- pg_statistic.stacoll4
+ *            "stacoll5": number, -- pg_statistic.stacoll5
+ *            -- stanumbersN are cast to string to aid array_in()
+ *            "stanumbers1": string, -- pg_statistic.stanumbers1::text
+ *            "stanumbers2": string, -- pg_statistic.stanumbers2::text
+ *            "stanumbers3": string, -- pg_statistic.stanumbers3::text
+ *            "stanumbers4": string, -- pg_statistic.stanumbers4::text
+ *            "stanumbers5": string, -- pg_statistic.stanumbers5::text
+ *            -- stavaluesN are cast to string to aid array_in()
+ *            "stavalues1": string, -- pg_statistic.stavalues1::text
+ *            "stavalues2": string, -- pg_statistic.stavalues2::text
+ *            "stavalues3": string, -- pg_statistic.stavalues3::text
+ *            "stavalues4": string, -- pg_statistic.stavalues4::text
+ *            "stavalues5": string -- pg_statistic.stavalues5::text
+ *         }
+ *       ]
+ *     }
+ *   ],
+ *   "types": [
+ *     -- export of all pg_type referenced in this json doc
+ *	   {
+ *        "oid": number, -- pg_type.oid
+ *        "typname": string, -- pg_type.typname
+ *        "nspname": string -- schema name for the pg_type
+ *     }
+ *   ],
+ *   "collations": [
+ *     -- export all pg_collation reference in this json doc
+ *     {
+ *        "oid": number, -- pg_collation.oid
+ *        "collname": string, -- pg_collation.collname
+ *        "nspname": string -- schema name for the pg_collation
+ *     }
+ *   ],
+ *   "operators": [
+ *     -- export all pg_operator reference in this json doc
+ *     {
+ *        "oid": number, -- pg_operator.oid
+ *        "collname": string, -- pg_oprname
+ *        "nspname": string -- schema name for the pg_operator
+ *     }
+ *   ],
+ *   "attributes": [
+ *     -- export all pg_attribute for the exported relation
+ *     {
+ *        "attnum": number, -- pg_attribute.attnum
+ *        "attname": string, -- pg_attribute.attname
+ *        "atttypid": number, -- pg_attribute.atttypid
+ *        "attcollation": number -- pg_attribute.attcollation
+ *     }
+ *   ]
+ *  }
+ *
+ * Each server verion exports a subset of this format. The exported format
+ * can and will change with each new version, and this function will have
+ * to account for those variations.
+ *
+ * Statistics imported from version 15 and higher can potentially have two
+ * result rows, one with stxdinherit = false and one for stxdinherit = true
+ *
+ */
+Datum
+pg_import_ext_stats(PG_FUNCTION_ARGS)
+{
+	const char *bq_sql =
+		"SELECT current_setting('server_version_num') AS current_version, eb.* "
+		"FROM jsonb_to_record($1) AS eb( "
+		"    server_version_num integer, "
+		"    stxoid Oid, "
+		"    reloid Oid, "
+		"    stxname text, "
+		"    stxnspname text, "
+		"    relname text, "
+		"    nspname text, "
+		"    stxkeys text, "
+		"    stxkind text, "
+		"    stxndistinct text, "
+		"    stxdependencies text, "
+		"    data jsonb, "
+		"    attributes jsonb, "
+		"    collations jsonb, "
+		"    operators jsonb, "
+		"    types jsonb) ";
+
+	enum {
+		BQ_CURRENT_VERSION_NUM = 0,
+		BQ_SERVER_VERSION_NUM,
+		BQ_STXOID,
+		BQ_RELOID,
+		BQ_STXNAME,
+		BQ_STXNSPNAME,
+		BQ_RELNAME,
+		BQ_NSPNAME,
+		BQ_STXKEYS,
+		BQ_STXKIND,
+		BQ_STXNDISTINCT,
+		BQ_STXDEPENDENCIES,
+		BQ_DATA,
+		BQ_ATTRIBUTES,
+		BQ_COLLATIONS,
+		BQ_OPERATORS,
+		BQ_TYPES,
+		NUM_BQ_COLS
+	};
+
+	/* All versions of the STXD query have the same column signature */
+	enum {
+		STXD_INHERIT = 0,
+		STXD_NDISTINCT,
+		STXD_DEPENDENCIES,
+		STXD_MCV,
+		STXD_EXPR,
+		NUM_STXD_COLS
+	};
+
+#define BQ_NARGS 1
+
+	Oid		stxid;
+	bool	validate;
+	bool	require_match_oids;
+
+	Oid		bq_argtypes[BQ_NARGS] = { JSONBOID };
+	Datum	bq_args[BQ_NARGS];
+
+	int		ret;
+
+	SPITupleTable  *tuptable;
+
+	Relation	rel;
+	TupleDesc	tupdesc;
+	int			natts;
+
+	HeapTuple	etup;
+	Relation	sd;
+
+	Form_pg_statistic_ext	stxform;
+
+	StatExtEntry   *stxentry;
+	VacAttrStats  **relstats; /* all relations attributes */
+	VacAttrStats  **extstats; /* entries relevenat to the extstat */
+	VacAttrStats  **expr_stats; /* expressions in the extstat */
+	int				nexprs;
+	int				ncols;
+
+	Datum	bq_datums[NUM_BQ_COLS];
+	bool	bq_nulls[NUM_BQ_COLS];
+
+	int		i;
+	int32	server_version_num;
+	int32	current_version_num;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("extended statistics oid cannot be NULL")));
+	stxid = PG_GETARG_OID(0);
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+	bq_args[0] = PG_GETARG_DATUM(1);
+
+	if (PG_ARGISNULL(2))
+		validate = false;
+	else
+		validate = PG_GETARG_BOOL(2);
+
+	if (PG_ARGISNULL(3))
+		require_match_oids = false;
+	else
+		require_match_oids = PG_GETARG_BOOL(3);
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	etup = SearchSysCacheCopy1(STATEXTOID, ObjectIdGetDatum(stxid));
+	if (!HeapTupleIsValid(etup))
+		elog(ERROR, "pg_statistic_ext entry for oid %u vanished during statistics import",
+			 stxid);
+
+	stxform = (Form_pg_statistic_ext) GETSTRUCT(etup);
+
+	rel = relation_open(stxform->stxrelid, ShareUpdateExclusiveLock);
+
+	tupdesc = RelationGetDescr(rel);
+	natts = tupdesc->natts;
+
+	relstats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
+	for (i = 0; i < natts; i++)
+		relstats[i] = examine_rel_attribute(rel, i+1, NULL);
+
+	stxentry = statext_create_entry(etup);
+	extstats = lookup_var_attr_stats(rel, stxentry->columns, stxentry->exprs,
+									 natts, relstats);
+
+	/* only the stats that were derived from pg_statistic_ext */
+	ncols = bms_num_members(stxentry->columns);
+	expr_stats = &extstats[ncols];
+	nexprs = list_length(stxentry->exprs);
+
+	/*
+	 * Connect to SPI manager
+	 */
+	if ((ret = SPI_connect()) < 0)
+		elog(ERROR, "SPI connect failure - returned %d", ret);
+
+	/*
+	 * Fetch the base level of the stats json. The results found there will
+	 * determine how the nested data will be handled.
+	 */
+	ret = SPI_execute_with_args(bq_sql, BQ_NARGS, bq_argtypes, bq_args,
+								NULL, true, 1);
+
+	/*
+	 * Only allow one qualifying tuple
+	 */
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	if (SPI_processed != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_CARDINALITY_VIOLATION),
+				 errmsg("pg_statistic_ext export JSON should return exactly one base object")));
+
+	tuptable = SPI_tuptable;
+	heap_deform_tuple(tuptable->vals[0], tuptable->tupdesc, bq_datums, bq_nulls);
+
+	/*
+	 * Check for valid combination of exported server_version_num to the local
+	 * server_version_num. We won't be reusing these values in a query so use
+	 * scratch datum/null vars.
+	 */
+	if (bq_nulls[BQ_CURRENT_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("current_version_num cannot be null")));
+
+	if (bq_nulls[BQ_SERVER_VERSION_NUM])
+		ereport(ERROR,
+				(errcode(ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE),
+				 errmsg("server_version_num cannot be null")));
+
+	current_version_num = DatumGetInt32(bq_datums[BQ_CURRENT_VERSION_NUM]);
+	server_version_num = DatumGetInt32(bq_datums[BQ_SERVER_VERSION_NUM]);
+
+	if (server_version_num <= 100000)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from servers below version 10.0")));
+
+	if (server_version_num > current_version_num)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("Cannot import statistics from server version %d to %d",
+						server_version_num, current_version_num)));
+
+	if (require_match_oids)
+	{
+		Oid imported_stxid;
+		Oid imported_relid;
+
+		if (bq_nulls[BQ_STXOID])
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("Expecting to import stxoid %u but stxoid is NULL",
+							stxid)));
+
+		imported_stxid = DatumGetObjectId(bq_datums[BQ_STXOID]);
+		if (stxid != imported_stxid)
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("Expecting to import stxoid %u but found stxoid %u",
+							stxid, imported_stxid)));
+
+		if (bq_nulls[BQ_RELOID])
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("Expecting to import reloid %u but reloid is NULL",
+							RelationGetRelid(rel))));
+
+		imported_relid = DatumGetObjectId(bq_datums[BQ_RELOID]);
+		if (RelationGetRelid(rel) != imported_relid)
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("Expecting to import reloid %u but found reloid %u",
+							RelationGetRelid(rel), imported_relid)));
+	}
+
+	/*
+	 * TODO: compare object/relation/schema names?
+	 * NameStr(RelationGetRelationName(rel))
+	 */
+
+	if (validate)
+	{
+		validate_exported_types(bq_datums[BQ_TYPES], bq_nulls[BQ_TYPES]);
+		validate_exported_collations(bq_datums[BQ_COLLATIONS], bq_nulls[BQ_COLLATIONS]);
+		validate_exported_operators(bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS]);
+		validate_exported_attributes(bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+	}
+
+	if (server_version_num >= 120000)
+	{
+		/* pg_statistic_ext_data export for modern versions */
+
+#define STXD_NARGS 1
+
+		Oid		stxd_argtypes[STXD_NARGS] = { JSONBOID };
+		Datum	stxd_args[STXD_NARGS] = { bq_datums[BQ_DATA] };
+		char	stxd_nulls[STXD_NARGS] = { bq_nulls[BQ_DATA] ? 'n' : ' ' };
+
+		const char *stxd_sql =
+			"SELECT d.* "
+			"FROM jsonb_to_recordset($1) AS d ( "
+			"    stxdinherit bool, "
+			"    stxdndistinct text, "
+			"    stxddependencies text, "
+			"    stxdmcv jsonb, "
+			"    stxdexpr jsonb) "
+			"ORDER BY d.stxdinherit ";
+
+		/* Versions 12+ cannot have ndistinct or dependencies on the base query */
+		if (!bq_nulls[BQ_STXNDISTINCT])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxndistinct not allowed on exports of servers v12 and later"),
+					 errhint("Use stxdndistinct instead")));
+
+		if(!bq_nulls[BQ_STXDEPENDENCIES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdependencies not allowed on exports of servers v12 and later"),
+					 errhint("Use stxddependencies instead")));
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 0);
+#undef STXD_NARGS
+	}
+	else
+	{
+#define STXD_NARGS 2
+		Oid		stxd_argtypes[STXD_NARGS] = {
+					TEXTOID,
+					TEXTOID };
+		Datum	stxd_args[STXD_NARGS] = {
+					bq_datums[BQ_STXNDISTINCT],
+					bq_datums[BQ_STXDEPENDENCIES] };
+		char	stxd_nulls[STXD_NARGS] = {
+					bq_nulls[BQ_STXNDISTINCT] ? 'n' : ' ',
+					bq_nulls[BQ_DATA]  ? 'n' : ' ' };
+
+		/* pg_statistic_ext_data export for versions prior to the table existing */
+		const char *stxd_sql =
+			"SELECT "
+			"	NULL::boolean AS stxdinherit, "
+			"   $1 AS stxdndistinct, "
+			"   $2 AS stxddependencies, "
+			"   NULL::jsonb AS stxdmcv, "
+			"   NULL::jsonb AS stxdexpr ";
+
+		ret = SPI_execute_with_args(stxd_sql, STXD_NARGS, stxd_argtypes, stxd_args,
+									stxd_nulls, true, 2);
+
+#undef STXD_NARGS
+	}
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	/* overwrite previous tuptable */
+	tuptable = SPI_tuptable;
+
+	for (i = 0; i < tuptable->numvals; i++)
+	{
+		Datum			stxd_datums[NUM_BQ_COLS];
+		bool			stxd_nulls[NUM_BQ_COLS];
+		bool			inh;
+		MCVList		   *mcvlist;
+		MVDependencies *dependencies;
+		MVNDistinct	   *ndistinct;
+		Datum			exprs;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, stxd_datums,
+						  stxd_nulls);
+
+		if ((!stxd_nulls[STXD_MCV]) && (server_version_num < 120000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdmv not allowed on exports of servers berfore v12")));
+
+		if ((!stxd_nulls[STXD_EXPR]) && (server_version_num < 140000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Key stxdexpr not allowed on exports of servers berfore v14")));
+
+		if ((!stxd_nulls[STXD_INHERIT]) && (server_version_num < 150000))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Extended statistics from servers prior to v15 cannot contain inherited stats")));
+
+		/* Versions prior to v15 never have stxdinhert set */
+		if (stxd_nulls[STXD_INHERIT])
+			inh = false;
+		else
+			inh = DatumGetBool(stxd_datums[STXD_INHERIT]);
+
+		ndistinct = statext_ndistinct_import(stxform->stxrelid,
+						stxd_datums[STXD_NDISTINCT], stxd_nulls[STXD_NDISTINCT],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		dependencies = statext_dependencies_import(stxform->stxrelid,
+						stxd_datums[STXD_DEPENDENCIES],
+						stxd_nulls[STXD_DEPENDENCIES],
+						bq_datums[BQ_ATTRIBUTES], bq_nulls[BQ_ATTRIBUTES]);
+
+		mcvlist = statext_mcv_import(stxd_datums[STXD_MCV], stxd_nulls[STXD_MCV],
+									 extstats);
+
+		exprs = import_expressions(stxd_datums[STXD_EXPR], stxd_nulls[STXD_EXPR],
+								   bq_datums[BQ_OPERATORS], bq_nulls[BQ_OPERATORS],
+								   expr_stats, nexprs);
+
+		statext_store(stxentry->statOid, inh, ndistinct, dependencies, mcvlist, exprs, extstats);
+	}
+
+	relation_close(rel, NoLock);
+	table_close(sd, RowExclusiveLock);
+	SPI_finish();
+
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/backend/statistics/mcv.c b/src/backend/statistics/mcv.c
index 6255cd1f4f..3bafde83d6 100644
--- a/src/backend/statistics/mcv.c
+++ b/src/backend/statistics/mcv.c
@@ -20,6 +20,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "fmgr.h"
 #include "funcapi.h"
 #include "nodes/nodeFuncs.h"
@@ -2177,3 +2178,194 @@ mcv_clause_selectivity_or(PlannerInfo *root, StatisticExtInfo *stat,
 
 	return s;
 }
+
+/*
+ * statext_mcv_import
+ *
+ * The mcv serialization is the json equivalent of the
+ * pg_mcv_list_items() result set:
+ * [
+ *   {
+ *     "index": number,
+ *     "values": [string],
+ *     "nulls": [bool],
+ *     "frequency": number,
+ *     "base_frequency": number
+ *   }
+ * ]
+ *
+ * The values are text strings that must be converted into datums of the type
+ * appropriate for their corresponding dimension. This means that we must
+ * cast individual datums rather than trying to use array_in().
+ *
+ */
+MCVList *
+statext_mcv_import(Datum mcv, bool mcv_null, VacAttrStats **extstats)
+{
+	const char *sql =
+		"SELECT m.*, array_length(m.nulls,1) AS ndims "
+		"FROM jsonb_to_recordset($1) AS m(index integer, values text[], "
+		"         nulls boolean[], frequency float8, base_frequency float8) "
+		"ORDER BY m.index ";
+
+	enum {
+		MCVS_INDEX = 0,
+		MCVS_VALUES,
+		MCVS_NULLS,
+		MCVS_FREQUENCY,
+		MCVS_BASE_FREQUENCY,
+		MCVS_NDIMS,
+		NUM_MCVS_COLS
+	};
+
+#define MCVS_NARGS 1
+
+	Oid		argtypes[MCVS_NARGS] = { JSONBOID };
+	Datum	args[MCVS_NARGS] = { mcv };
+	char	argnulls[MCVS_NARGS] = { mcv_null ? 'n' : ' ' };
+	int		nitems = 0;
+	int		ndims = 0;
+	int		ret;
+	int		i;
+
+	MCVList		   *mcvlist;
+	SPITupleTable  *tuptable;
+	Oid				ioparams[STATS_MAX_DIMENSIONS];
+	FmgrInfo		finfos[STATS_MAX_DIMENSIONS];
+
+	ret = SPI_execute_with_args(sql, MCVS_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals > 0)
+	{
+		/* ndims will be same for all rows, so just check first one */
+		bool	isnull;
+		Datum	d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								  MCVS_NDIMS+1, &isnull);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of mcv dimensions")));
+
+		ndims = DatumGetInt32(d);
+		nitems = tuptable->numvals;
+	}
+
+	mcvlist = (MCVList *) palloc0(offsetof(MCVList, items) +
+								  (sizeof(MCVItem) * nitems));
+
+	mcvlist->magic = STATS_MCV_MAGIC;
+	mcvlist->type = STATS_MCV_TYPE_BASIC;
+	mcvlist->nitems = nitems;
+	mcvlist->ndimensions = ndims;
+
+	/* We will need these input functions $nitems times. */
+	for (i = 0; i < ndims; i++)
+	{
+		Oid		typid = extstats[i]->attrtypid;
+		Oid		infunc;
+
+		mcvlist->types[i] = typid;
+		getTypeInputInfo(typid, &infunc, &ioparams[i]);
+		fmgr_info(infunc, &finfos[i]);
+	}
+
+	for (i = 0; i < nitems; i++)
+	{
+		MCVItem	   *item = &mcvlist->items[i];
+		Datum		datums[NUM_MCVS_COLS];
+		bool		nulls[NUM_MCVS_COLS];
+		ArrayType  *arr;
+		Datum      *elems;
+		bool       *elnulls;
+		int         nelems;
+
+		int			d;
+
+		heap_deform_tuple(tuptable->vals[i], tuptable->tupdesc, datums, nulls);
+
+		if (nulls[MCVS_VALUES])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"values")));
+		if (nulls[MCVS_NULLS])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"nulls")));
+		if (nulls[MCVS_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"frequency")));
+		if (nulls[MCVS_BASE_FREQUENCY])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv export cannot have NULL %s",
+							"base_frequency")));
+
+		item->frequency = DatumGetFloat8(datums[MCVS_FREQUENCY]);
+		item->base_frequency = DatumGetFloat8(datums[MCVS_BASE_FREQUENCY]);
+		item->values = (Datum *) palloc(sizeof(Datum) * ndims);
+		item->isnull = (bool *) palloc(sizeof(bool) * ndims);
+
+		arr = DatumGetArrayTypeP(datums[MCVS_NULLS]);
+		deconstruct_array(arr, BOOLOID, 1, true, 'c', &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"nulls", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			if (elnulls[d])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("extended statistic mcv %s array cannot contain NULL values",
+								"nulls")));
+			item->isnull[d] = DatumGetBool(elems[d]);
+		}
+
+		arr = DatumGetArrayTypeP(datums[MCVS_VALUES]);
+		deconstruct_array_builtin(arr, TEXTOID, &elems, &elnulls, &nelems);
+
+		if (nelems != ndims)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("extended statistic mcv %s array expected %d elements but %d found",
+							"values", ndims, nelems)));
+
+		for (d = 0; d < ndims; d++)
+		{
+			/* if the element is a known NULL, nothing to decode */
+			if (item->isnull[d])
+				item->values[d] = (Datum) 0;
+			else
+			{
+				char   *s;
+
+				if (elnulls[d])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("extended statistic mcv nulls array in conflict with values array")));
+
+				s = TextDatumGetCString(elems[d]);
+
+				item->values[d] = InputFunctionCall(&finfos[d], s, ioparams[d],
+													extstats[d]->attrtypmod);
+				pfree(s);
+			}
+		}
+	}
+
+	return mcvlist;
+}
diff --git a/src/backend/statistics/mvdistinct.c b/src/backend/statistics/mvdistinct.c
index ee1134cc37..d84eee47ee 100644
--- a/src/backend/statistics/mvdistinct.c
+++ b/src/backend/statistics/mvdistinct.c
@@ -28,9 +28,11 @@
 #include "access/htup_details.h"
 #include "catalog/pg_statistic_ext.h"
 #include "catalog/pg_statistic_ext_data.h"
+#include "executor/spi.h"
 #include "lib/stringinfo.h"
 #include "statistics/extended_stats_internal.h"
 #include "statistics/statistics.h"
+#include "utils/builtins.h"
 #include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -698,3 +700,161 @@ generate_combinations(CombinationGenerator *state)
 
 	pfree(current);
 }
+
+/*
+ * statext_dependencies_import
+ *
+ * The ndinstinct serialization is a string that looks like
+ *       {"2, 3": 1521, "3, -1": 4}
+ *
+ *   This structure can be coerced into JSON, but we must use JSON
+ *   over JSONB because JSON preserves key order and JSONB does not.
+ *
+ *   The key side integers represent attnums in the exported table, and these
+ *   may not line up with the attnums in the destination table so we match
+ *   them by name.
+ *
+ *   Negative integers represent expressions columns that have no
+ *   corresponding match in the exported attributes. We leave those
+ *   attnums as-is. Positive integers are looked up in the exported
+ *   attributes and the attname there is then compared to pg_attribute
+ *   names in the underlying table, and that tuples attnum is used instead.
+ */
+MVNDistinct *
+statext_ndistinct_import(Oid relid, Datum ndistinct, bool ndistinct_null,
+						 Datum attributes, bool attributes_null)
+{
+	MVNDistinct	   *result;
+	int				nitems;
+
+#define NDIST_NARGS 3
+
+	Oid			argtypes[NDIST_NARGS] = { OIDOID, TEXTOID, JSONBOID };
+	Datum		args[NDIST_NARGS] = { relid, ndistinct , attributes };
+	char		argnulls[NDIST_NARGS] = { ' ',
+					ndistinct_null ? 'n' : ' ',
+					attributes_null ? 'n' : ' ' };
+
+	const char *sql =
+		"SELECT "
+		"    i.itemord, "
+		"    a.attrord, "
+		"    a.exp_attnum, "
+		"    ea.attname AS exp_attname, "
+		"    CASE "
+		"        WHEN a.exp_attnum < 0 THEN a.exp_attnum "
+		"        ELSE pga.attnum "
+		"    END AS attnum, "
+		"    i.ndistinct::float8 AS ndistinct, "
+		"    COUNT(*) OVER (PARTITION BY i.itemord) AS num_attrs, "
+		"    MAX(i.itemord) OVER () AS num_items "
+		"FROM json_each_text($2::json) "
+		"     WITH ORDINALITY AS i(attrlist, ndistinct, itemord) "
+		"CROSS JOIN LATERAL unnest(string_to_array(i.attrlist, ', ')::int2[]) "
+		"     WITH ORDINALITY AS a(exp_attnum, attrord) "
+		"LEFT JOIN LATERAL jsonb_to_recordset($3) AS ea(attnum int2, attname text) "
+		"     ON ea.attnum = a.exp_attnum AND a.exp_attnum > 0 "
+		"LEFT JOIN pg_attribute AS pga "
+		"     ON pga.attrelid = $1 AND pga.attname = ea.attname "
+		"ORDER BY i.itemord, a.attrord ";
+
+	enum {
+		NDIST_ITEMORD = 0,
+		NDIST_ATTRORD,
+		NDIST_EXP_ATTNUM,
+		NDIST_EXP_ATTNAME,
+		NDIST_ATTNUM,
+		NDIST_NDISTINCT,
+		NDIST_NUM_ATTRS,
+		NDIST_NUM_ITEMS,
+		NUM_NDIST_COLS
+	};
+
+	SPITupleTable  *tuptable;
+	int				ret;
+	int				j;
+
+	ret = SPI_execute_with_args(sql, NDIST_NARGS, argtypes, args, argnulls, true, 0);
+
+	if (ret != SPI_OK_SELECT)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("statistic export JSON is not in proper format")));
+
+	tuptable = SPI_tuptable;
+	if (tuptable->numvals == 0)
+		nitems = 0;
+	else
+	{
+		bool isnull;
+		Datum d = SPI_getbinval(tuptable->vals[0], tuptable->tupdesc,
+								NDIST_NUM_ITEMS+1, &isnull);
+		nitems = DatumGetInt32(d);
+
+		if (isnull)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Indeterminate number of dependencies")));
+	}
+
+	result = palloc(offsetof(MVNDistinct, items) +
+					(nitems * sizeof(MVNDistinctItem)));
+	result->magic = STATS_NDISTINCT_MAGIC;
+	result->type = STATS_NDISTINCT_TYPE_BASIC;
+	result->nitems = nitems;
+
+	for (j = 0; j < tuptable->numvals; j++)
+	{
+		Datum	datums[NUM_NDIST_COLS];
+		bool	nulls[NUM_NDIST_COLS];
+		int		i;
+		int		a;
+		int		natts;
+
+		MVNDistinctItem *item;
+
+		heap_deform_tuple(tuptable->vals[j], tuptable->tupdesc, datums, nulls);
+
+		Assert(!nulls[NDIST_ITEMORD]);
+		i = DatumGetInt32(datums[NDIST_ITEMORD]) - 1;
+		item = &result->items[i];
+		Assert(!nulls[NDIST_ATTRORD]);
+		a = DatumGetInt32(datums[NDIST_ATTRORD]) - 1;
+
+		if (a == 0)
+		{
+			/* New item */
+			Assert(!nulls[NDIST_NUM_ATTRS]);
+			natts = DatumGetInt32(datums[NDIST_NUM_ATTRS]);
+			item->nattributes = natts;
+			item->attributes = palloc(sizeof(AttrNumber) * natts);
+			Assert(!nulls[NDIST_NDISTINCT]);
+			item->ndistinct = DatumGetFloat8(datums[NDIST_NDISTINCT]);
+		}
+
+		if (!nulls[NDIST_ATTNUM])
+			item->attributes[a] =
+				DatumGetInt16(datums[NDIST_ATTNUM]);
+		else if (nulls[NDIST_EXP_ATTNUM])
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ndistinct exported attnum cannot be null")));
+		else
+		{
+			AttrNumber exp_attnum = DatumGetInt16(datums[NDIST_EXP_ATTNUM]);
+
+			if (nulls[NDIST_EXP_ATTNAME])
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("ndistinct has no exported name for attnum %d",
+								exp_attnum)));
+
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("Dependency tried to match attnum %d by name (%s) but found no match",
+						 exp_attnum, TextDatumGetCString(datums[NDIST_EXP_ATTNAME]))));
+		}
+	}
+
+	return result;
+}
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
index 90d117c0d6..d8757040e1 100644
--- a/src/backend/statistics/statistics.c
+++ b/src/backend/statistics/statistics.c
@@ -767,7 +767,6 @@ import_pg_statistics(Relation rel, Relation sd, int server_version_num,
 
 			char   *imported_typename;
 			char   *imported_typeschema;
-					
 
 			if (pgs_nulls[PGS_EXP_TYPNAME])
 				ereport(ERROR,
@@ -785,7 +784,7 @@ import_pg_statistics(Relation rel, Relation sd, int server_version_num,
 			imported_typeschema = TextDatumGetCString(pgs_datums[PGS_EXP_TYPSCHEMA]);
 
 			if ((strcmp(local_typename, imported_typename) != 0) ||
-			    (strcmp(local_typeschema, imported_typeschema) != 0))
+					(strcmp(local_typeschema, imported_typeschema) != 0))
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 						 errmsg("Attribute %d has type %s.%s but imported type is %s.%s",
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
index 5ab51c5aa0..8e6e04eb76 100644
--- a/src/test/regress/expected/stats_export_import.out
+++ b/src/test/regress/expected/stats_export_import.out
@@ -22,6 +22,7 @@ SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.comple
 UNION ALL
 SELECT 4, 'four', NULL, NULL;
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
 -- Capture pg_statistic values for table and index
@@ -44,6 +45,25 @@ FROM stats_export_import.pg_statistic_capture;
      5
 (1 row)
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ count 
+-------
+     1
+(1 row)
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -323,6 +343,173 @@ WHERE :'debug'::boolean;
 ------------------
 (0 rows)
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+ ext_stats_json 
+----------------
+(0 rows)
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
@@ -334,12 +521,14 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
--- Create empty copy tables
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 -- Verify no stats for these new tables
 SELECT COUNT(*)
 FROM pg_statistic
@@ -459,7 +648,7 @@ SELECT pg_import_rel_stats(
         'stats_export_import.test'::regclass,
         :'table_stats_json'::jsonb,
         true,
-        true);
+        false);
  pg_import_rel_stats 
 ---------------------
  t
@@ -469,12 +658,25 @@ SELECT pg_import_rel_stats(
         'stats_export_import.is_odd'::regclass,
         :'index_stats_json'::jsonb,
         true,
-        true);
+        false);
  pg_import_rel_stats 
 ---------------------
  t
 (1 row)
 
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        false)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ pg_import_ext_stats 
+---------------------
+ t
+(1 row)
+
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
         stakind1, stakind2, stakind3, stakind4, stakind5,
@@ -528,3 +730,62 @@ ORDER BY relname;
  test    |         4
 (2 rows)
 
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+ stxdinherit | stxdndistinct | stxddependencies | stxdmcv | stxdexpr 
+-------------+---------------+------------------+---------+----------
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
+ staattnum | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 
+-----------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----
+(0 rows)
+
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
index 9a80eebeec..85356bfd69 100644
--- a/src/test/regress/sql/stats_export_import.sql
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -26,6 +26,7 @@ UNION ALL
 SELECT 4, 'four', NULL, NULL;
 
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Generate statistics on table with data
 ANALYZE stats_export_import.test;
@@ -47,6 +48,22 @@ WHERE starelid IN ('stats_export_import.test'::regclass,
 SELECT COUNT(*)
 FROM stats_export_import.pg_statistic_capture;
 
+-- Capture pg_statistic values for table and index
+CREATE TABLE stats_export_import.pg_statistic_ext_data_capture
+AS
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+SELECT COUNT(*)
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
 -- Export stats
 SELECT
     jsonb_build_object(
@@ -322,19 +339,186 @@ WHERE r.oid = 'stats_export_import.is_odd'::regclass
 SELECT jsonb_pretty(:'index_stats_json'::jsonb) AS index_stats_json
 WHERE :'debug'::boolean;
 
+SELECT
+    jsonb_build_object(
+        'server_version_num', current_setting('server_version_num'),
+        'stxoid', e.oid,
+        'reloid', r.oid,
+        'stxname', e.stxname,
+        'stxnspname', en.nspname,
+        'relname', r.relname,
+        'nspname', n.nspname,
+        'stxkeys', e.stxkeys::text,
+        'stxkind', e.stxkind::text,
+        'data',
+        (
+            SELECT
+                array_agg(r ORDER by r.stxdinherit)
+            FROM (
+                SELECT
+                    sd.stxdinherit,
+                    sd.stxdndistinct::text AS stxdndistinct,
+                    sd.stxddependencies::text AS stxddependencies,
+                    (
+                        SELECT
+                            array_agg(mcvl)
+                        FROM pg_mcv_list_items(sd.stxdmcv) AS mcvl
+                        WHERE sd.stxdmcv IS NOT NULL
+                    ) AS stxdmcv,
+                    (
+                        SELECT
+                            array_agg(r ORDER BY r.stainherit, r.staattnum)
+                        FROM (
+                            SELECT
+                                 s.staattnum,
+                                 s.stainherit,
+                                 s.stanullfrac,
+                                 s.stawidth,
+                                 s.stadistinct,
+                                 s.stakind1,
+                                 s.stakind2,
+                                 s.stakind3,
+                                 s.stakind4,
+                                 s.stakind5,
+                                 s.staop1,
+                                 s.staop2,
+                                 s.staop3,
+                                 s.staop4,
+                                 s.staop5,
+                                 s.stacoll1,
+                                 s.stacoll2,
+                                 s.stacoll3,
+                                 s.stacoll4,
+                                 s.stacoll5,
+                                 s.stanumbers1::text AS stanumbers1,
+                                 s.stanumbers2::text AS stanumbers2,
+                                 s.stanumbers3::text AS stanumbers3,
+                                 s.stanumbers4::text AS stanumbers4,
+                                 s.stanumbers5::text AS stanumbers5,
+                                 s.stavalues1::text AS stavalues1,
+                                 s.stavalues2::text AS stavalues2,
+                                 s.stavalues3::text AS stavalues3,
+                                 s.stavalues4::text AS stavalues4,
+                                 s.stavalues5::text AS stavalues5
+                            FROM unnest(sd.stxdexpr) AS s
+                            WHERE sd.stxdexpr IS NOT NULL
+                        ) AS r
+                    ) AS stxdexpr
+                FROM pg_statistic_ext_data AS sd
+                WHERE sd.stxoid = e.oid
+            ) r
+        ),
+        'types',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    a.atttypid AS oid,
+                    t.typname,
+                    n.nspname
+                FROM pg_attribute AS a
+                JOIN pg_type AS t ON t.oid = a.atttypid
+                JOIN pg_namespace AS n ON n.oid = t.typnamespace
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        ),
+        'collations',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT
+                    e.oid,
+                    c.collname,
+                    n.nspname
+                FROM (
+                    SELECT a.attcollation AS oid
+                    FROM pg_attribute AS a
+                    WHERE a.attrelid = r.oid
+                    AND NOT a.attisdropped
+                    AND a.attnum > 0
+                    UNION
+                    SELECT u.collid
+                    FROM pg_statistic_ext_data AS sd
+                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                    CROSS JOIN LATERAL unnest(ARRAY[
+                                        s.stacoll1, s.stacoll2,
+                                        s.stacoll3, s.stacoll4,
+                                        s.stacoll5]) AS u(collid)
+                    WHERE sd.stxoid = e.oid
+                    AND sd.stxdexpr IS NOT NULL
+                    ) AS e
+                JOIN pg_collation AS c ON c.oid = e.oid
+                JOIN pg_namespace AS n ON n.oid = c.collnamespace
+            ) AS r
+        ),
+        'operators',
+        (
+            SELECT
+                array_agg(r)
+            FROM (
+                SELECT DISTINCT
+                    o.oid,
+                    o.oprname,
+                    n.nspname
+                FROM pg_statistic_ext_data AS sd
+                CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s
+                CROSS JOIN LATERAL unnest(ARRAY[
+                                    s.staop1, s.staop2,
+                                    s.staop3, s.staop4,
+                                    s.staop5]) AS u(opid)
+                JOIN pg_operator AS o ON o.oid = u.oid
+                JOIN pg_namespace AS n ON n.oid = o.oprnamespace
+                WHERE sd.stxoid = e.oid
+                AND sd.stxdexpr IS NOT NULL
+            ) AS r
+        ),
+        'attributes',
+        (
+            SELECT
+                array_agg(r ORDER BY r.attnum)
+            FROM (
+                SELECT
+                    a.attnum,
+                    a.attname,
+                    a.atttypid,
+                    a.attcollation
+                FROM pg_attribute AS a
+                WHERE a.attrelid = r.oid
+                AND NOT a.attisdropped
+                AND a.attnum > 0
+            ) AS r
+        )
+    ) AS ext_stats_json
+FROM pg_class r
+JOIN pg_statistic_ext AS e ON e.stxrelid = r.oid
+JOIN pg_namespace AS en ON en.oid = e.stxnamespace
+JOIN pg_namespace AS n ON n.oid = r.relnamespace
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+\gset
+
+SELECT jsonb_pretty(:'ext_stats_json'::jsonb) AS ext_stats_json
+WHERE :'debug'::boolean;
+
 SELECT relname, reltuples
 FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
 
--- Move table and index out of the way
+-- Move table and index and extended stats out of the way
 ALTER TABLE stats_export_import.test RENAME TO test_orig;
 ALTER INDEX stats_export_import.is_odd RENAME TO is_odd_orig;
+ALTER STATISTICS stats_export_import.evens_test RENAME TO evens_test_orig;
 
--- Create empty copy tables
+-- Create empty copy tables and objects
 CREATE TABLE stats_export_import.test(LIKE stats_export_import.test_orig);
 CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+CREATE STATISTICS stats_export_import.evens_test ON name, ((comp).a % 2 = 0) FROM stats_export_import.test;
 
 -- Verify no stats for these new tables
 SELECT COUNT(*)
@@ -448,13 +632,22 @@ SELECT pg_import_rel_stats(
         'stats_export_import.test'::regclass,
         :'table_stats_json'::jsonb,
         true,
-        true);
+        false);
 
 SELECT pg_import_rel_stats(
         'stats_export_import.is_odd'::regclass,
         :'index_stats_json'::jsonb,
         true,
-        true);
+        false);
+
+SELECT pg_import_ext_stats(
+        e.oid,
+        :'ext_stats_json'::jsonb,
+        true,
+        false)
+FROM pg_statistic_ext AS e
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
 
 -- This should return 0 rows
 SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
@@ -497,3 +690,51 @@ FROM pg_class
 WHERE oid IN ('stats_export_import.test'::regclass,
               'stats_export_import.is_odd'::regclass)
 ORDER BY relname;
+
+-- This should return 0 rows
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test'
+EXCEPT
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture;
+
+-- This should return 0 rows
+SELECT *
+FROM stats_export_import.pg_statistic_ext_data_capture
+EXCEPT
+SELECT  d.stxdinherit,
+        d.stxdndistinct::text AS stxdndistinct,
+        d.stxddependencies::text AS stxddependencies,
+        d.stxdmcv::text AS stxdmcv,
+        d.stxdexpr::text AS stxdexpr
+FROM pg_statistic_ext AS e
+JOIN pg_statistic_ext_data AS d ON d.stxoid = e.oid
+WHERE e.stxrelid = 'stats_export_import.test'::regclass
+AND e.stxname = 'evens_test';
+
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        sv1, sv2, sv3, sv4, sv5
+FROM stats_export_import.pg_statistic_capture
+WHERE :'debug'::boolean;
+
+SELECT staattnum, stainherit, stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1::text AS sv1, stavalues2::text AS sv2, stavalues3::text AS sv3,
+        stavalues4::text AS sv4, stavalues5::text AS sv5
+FROM pg_statistic
+WHERE starelid IN ('stats_export_import.test'::regclass,
+                    'stats_export_import.is_odd'::regclass)
+AND :'debug'::boolean;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 2be0a30d4d..6f41c7a292 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28787,12 +28787,38 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
        </para>
        <para>
         If <parameter>require_match_oids</parameter> is set to <literal>true</literal>,
-        then the import will fail if the imported oids for <structname>pt_type</structname>,
+        then the import will fail if the imported oids for <structname>pg_type</structname>,
         <structname>pg_collation</structname>, and <structname>pg_operator</structname> do
         not match the values specified in <parameter>relation_json</parameter>, as would be expected
         in a binary upgrade. These assumptions would not be true when restoring from a dump.
        </para></entry>
       </row>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_import_ext_stats</primary>
+        </indexterm>
+        <function>pg_import_ext_stats</function> ( <parameter>extended statisticss object</parameter> <type>oid</type>, <parameter>extended_stats</parameter> <type>jsonb</type> <parameter>validate</parameter> <type>boolean</type>, <parameter>require_match_oids</parameter> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Modifies the <structname>pg_statistic_ext_data</structname> rows for the
+        <structfield>oid</structfield> matching
+        <parameter>extended statistics object</parameter> are transactionally
+        replaced with the values found in <parameter>extended_stats</parameter>.
+        The purpose of this function is to apply statistics values in an upgrade
+        situation that are "good enough" for system operation until they are
+        replaced by the next auto-analyze. This function could be used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        If <parameter>validate</parameter> is set to <literal>true</literal>,
+        then the function will perform a series of data consistency checks on
+        the data in <parameter>extended_stats</parameter> before attempting to
+        import statistics. Any inconsistencies found will raise an error.
+       </para></entry>
+      </row>
      </tbody>
     </tgroup>
    </table>
-- 
2.43.2

From 78c35f045bb3194bf03b8236b2ac951e4082e2a1 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 17 Feb 2024 14:20:55 -0500
Subject: [PATCH v6 3/4] Add common functions for exporting statistics.

Creates functions that aid the caller in generating the
version-appropriate function for extracting pg_statistic and
pg_statistic_ext data, and forming the SQL command to import those same
statistics.

These functions will be used by pg_export_stats and pg_dump.
---
 src/include/fe_utils/stats_export.h |  35 ++
 src/fe_utils/Makefile               |   1 +
 src/fe_utils/meson.build            |   1 +
 src/fe_utils/stats_export.c         | 880 ++++++++++++++++++++++++++++
 4 files changed, 917 insertions(+)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..4f80d110cf
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+extern const char *stats_export_rel_query(int server_version_num);
+extern const char *stats_export_ext_query(int server_version_num);
+
+extern void stats_export_print_rel_import(FILE *outf,
+										  const char *nspname_literal,
+										  const char *relname_literal,
+										  const char *stats_json_literal,
+										  bool validate,
+										  bool require_match);
+extern void stats_export_print_ext_import(FILE *outf,
+										  const char *nspname_literal,
+										  const char *relname_literal,
+										  const char *stxname_literal,
+										  const char *ext_stats_json_literal,
+										  bool validate,
+										  bool require_match);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..1815793c9d
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,880 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+
+/*
+ * The following are query fragments that build one or more JSONB objects
+ * in the format expected by pg_import_rel_stats(). They cannot be used
+ * unmodified, as they are missing the SELECT clause. In addition, they are
+ * missing a WHERE clause to filter results. The expectation is that the
+ * the caller will do one of the following:
+ *   - Prepend "SELECT stats_json " and append a WHERE clause to the query
+ *     that identifies a single object.
+ *   - Similar to the previous option, but make it a correlated subquery in
+ *     a larger query.
+ *   - Prepend a SELECT list to the query and append a WHERE clause that
+ *     refines the objects selected.
+ */
+
+/*
+ * pg_statitic on versions 12+ have the same rel stats layout
+ */
+const char *stats_export_rel_query_v12 =
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'reltuples', r.reltuples, "
+	"        'relpages', r.relpages, "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_type AS t "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_catalog.pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_operator AS o "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.oid "
+	"                    FROM pg_catalog.pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ), "
+	"        'statistics', "
+	"        ( "
+	"            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                     s.staattnum, "
+	"                     s.stainherit, "
+	"                     s.stanullfrac, "
+	"                     s.stawidth, "
+	"                     s.stadistinct, "
+	"                     s.stakind1, "
+	"                     s.stakind2, "
+	"                     s.stakind3, "
+	"                     s.stakind4, "
+	"                     s.stakind5, "
+	"                     s.staop1, "
+	"                     s.staop2, "
+	"                     s.staop3, "
+	"                     s.staop4, "
+	"                     s.staop5, "
+	"                     s.stacoll1, "
+	"                     s.stacoll2, "
+	"                     s.stacoll3, "
+	"                     s.stacoll4, "
+	"                     s.stacoll5, "
+	"                     s.stanumbers1::text AS stanumbers1, "
+	"                     s.stanumbers2::text AS stanumbers2, "
+	"                     s.stanumbers3::text AS stanumbers3, "
+	"                     s.stanumbers4::text AS stanumbers4, "
+	"                     s.stanumbers5::text AS stanumbers5, "
+	"                     s.stavalues1::text AS stavalues1, "
+	"                     s.stavalues2::text AS stavalues2, "
+	"                     s.stavalues3::text AS stavalues3, "
+	"                     s.stavalues4::text AS stavalues4, "
+	"                     s.stavalues5::text AS stavalues5 "
+	"                FROM pg_catalog.pg_statistic AS s "
+	"                WHERE s.starelid = r.oid "
+	"            ) AS sr "
+	"        ) "
+	"    ) AS stats_json "
+	"FROM pg_catalog.pg_class AS r "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/*
+ * pg_statitic on versions 10-11 are missing the pg_statistic.stacollN columns
+ */
+const char *stats_export_rel_query_v10 =
+	"    jsonb_build_object( "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_type AS t "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_operator AS o "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.oid "
+	"                    FROM pg_catalog.pg_statistic AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE s.starelid = r.oid "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ), "
+	"        'statistics', "
+	"        ( "
+	"            SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                     s.staattnum, "
+	"                     s.stainherit, "
+	"                     s.stanullfrac, "
+	"                     s.stawidth, "
+	"                     s.stadistinct, "
+	"                     s.stakind1, "
+	"                     s.stakind2, "
+	"                     s.stakind3, "
+	"                     s.stakind4, "
+	"                     s.stakind5, "
+	"                     s.staop1, "
+	"                     s.staop2, "
+	"                     s.staop3, "
+	"                     s.staop4, "
+	"                     s.staop5, "
+	"                     s.stanumbers1::text AS stanumbers1, "
+	"                     s.stanumbers2::text AS stanumbers2, "
+	"                     s.stanumbers3::text AS stanumbers3, "
+	"                     s.stanumbers4::text AS stanumbers4, "
+	"                     s.stanumbers5::text AS stanumbers5, "
+	"                     s.stavalues1::text AS stavalues1, "
+	"                     s.stavalues2::text AS stavalues2, "
+	"                     s.stavalues3::text AS stavalues3, "
+	"                     s.stavalues4::text AS stavalues4, "
+	"                     s.stavalues5::text AS stavalues5 "
+	"                FROM pg_catalog.pg_statistic AS s "
+	"                WHERE s.starelid = r.oid "
+	"            ) AS sr "
+	"        ) "
+	"    ) AS stats_json "
+	"FROM pg_catalog.pg_class AS r "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/*
+ * The following are query fragments that build one or more JSONB objects
+ * in the format expected by pg_import_rel_stats(), and it is expected that
+ * they will be utilized in the same ways.
+ */
+
+const char *stats_export_ext_query_v15 =
+/* v15+ have the same format */
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(dr ORDER by dr.stxdinherit) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdinherit, "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_catalog.pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv, "
+	"                    ( "
+	"                        SELECT array_agg(sr ORDER BY sr.stainherit, sr.staattnum) "
+	"                        FROM ( "
+	"                            SELECT "
+	"                                 s.staattnum, "
+	"                                 s.stainherit, "
+	"                                 s.stanullfrac, "
+	"                                 s.stawidth, "
+	"                                 s.stadistinct, "
+	"                                 s.stakind1, "
+	"                                 s.stakind2, "
+	"                                 s.stakind3, "
+	"                                 s.stakind4, "
+	"                                 s.stakind5, "
+	"                                 s.staop1, "
+	"                                 s.staop2, "
+	"                                 s.staop3, "
+	"                                 s.staop4, "
+	"                                 s.staop5, "
+	"                                 s.stacoll1, "
+	"                                 s.stacoll2, "
+	"                                 s.stacoll3, "
+	"                                 s.stacoll4, "
+	"                                 s.stacoll5, "
+	"                                 s.stanumbers1::text AS stanumbers1, "
+	"                                 s.stanumbers2::text AS stanumbers2, "
+	"                                 s.stanumbers3::text AS stanumbers3, "
+	"                                 s.stanumbers4::text AS stanumbers4, "
+	"                                 s.stanumbers5::text AS stanumbers5, "
+	"                                 s.stavalues1::text AS stavalues1, "
+	"                                 s.stavalues2::text AS stavalues2, "
+	"                                 s.stavalues3::text AS stavalues3, "
+	"                                 s.stavalues4::text AS stavalues4, "
+	"                                 s.stavalues5::text AS stavalues5 "
+	"                            FROM unnest(sd.stxdexpr) AS s "
+	"                            WHERE sd.stxdexpr IS NOT NULL "
+	"                        ) AS sr "
+	"                    ) AS stxdexpr "
+	"                FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) AS dr "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_type AS t "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_operator AS o "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.opid "
+	"                    FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_catalog.pg_class r "
+	"JOIN pg_catalog.pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_catalog.pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/* v14 is like v15, but lacks stxdinherit on pg_statistic_ext_data */
+const char *stats_export_ext_query_v14 =
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(dr) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_catalog.pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv, "
+	"                    ( "
+	"                        SELECT array_agg(sr ORDER BY sr.staattnum) "
+	"                        FROM ( "
+	"                            SELECT "
+	"                                 s.staattnum, "
+	"                                 s.stanullfrac, "
+	"                                 s.stawidth, "
+	"                                 s.stadistinct, "
+	"                                 s.stakind1, "
+	"                                 s.stakind2, "
+	"                                 s.stakind3, "
+	"                                 s.stakind4, "
+	"                                 s.stakind5, "
+	"                                 s.staop1, "
+	"                                 s.staop2, "
+	"                                 s.staop3, "
+	"                                 s.staop4, "
+	"                                 s.staop5, "
+	"                                 s.stacoll1, "
+	"                                 s.stacoll2, "
+	"                                 s.stacoll3, "
+	"                                 s.stacoll4, "
+	"                                 s.stacoll5, "
+	"                                 s.stanumbers1::text AS stanumbers1, "
+	"                                 s.stanumbers2::text AS stanumbers2, "
+	"                                 s.stanumbers3::text AS stanumbers3, "
+	"                                 s.stanumbers4::text AS stanumbers4, "
+	"                                 s.stanumbers5::text AS stanumbers5, "
+	"                                 s.stavalues1::text AS stavalues1, "
+	"                                 s.stavalues2::text AS stavalues2, "
+	"                                 s.stavalues3::text AS stavalues3, "
+	"                                 s.stavalues4::text AS stavalues4, "
+	"                                 s.stavalues5::text AS stavalues5 "
+	"                            FROM unnest(sd.stxdexpr) AS s "
+	"                            WHERE sd.stxdexpr IS NOT NULL "
+	"                        ) AS sr "
+	"                    ) AS stxdexpr "
+	"                FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) dr "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            select array_agg(tr ORDER BY tr.oid) "
+	"            from ( "
+	"                select "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                from pg_catalog.pg_type as t "
+	"                join pg_catalog.pg_namespace as n on n.oid = t.typnamespace "
+	"                where t.oid in ( "
+	"                    select a.atttypid "
+	"                    from pg_catalog.pg_attribute as a "
+	"                    where a.attrelid = r.oid "
+	"                    and not a.attisdropped "
+	"                    and a.attnum > 0 "
+	"                ) "
+	"            ) as tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    UNION "
+	"                    SELECT u.collid "
+	"                    FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.stacoll1, s.stacoll2, "
+	"                                        s.stacoll3, s.stacoll4, "
+	"                                        s.stacoll5]) AS u(collid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'operators', "
+	"        ( "
+	"            SELECT array_agg(p ORDER BY p.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    o.oid, "
+	"                    o.oprname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_operator AS o "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = o.oprnamespace "
+	"                WHERE o.oid IN ( "
+	"                    SELECT u.opid "
+	"                    FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                    CROSS JOIN LATERAL unnest(sd.stxdexpr) AS s "
+	"                    CROSS JOIN LATERAL unnest(ARRAY[ "
+	"                                        s.staop1, s.staop2, "
+	"                                        s.staop3, s.staop4, "
+	"                                        s.staop5]) AS u(opid) "
+	"                    WHERE sd.stxoid = e.oid "
+	"                    AND sd.stxdexpr IS NOT NULL "
+	"                    ) "
+	"            ) AS p "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_catalog.pg_class r "
+	"JOIN pg_catalog.pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_catalog.pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/* v12-v13 are like v14, but lack stxdexpr on pg_statistic_ext_data */
+const char *stats_export_ext_query_v12 =
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'data', "
+	"        ( "
+	"            SELECT array_agg(r) "
+	"            FROM ( "
+	"                SELECT "
+	"                    sd.stxdndistinct::text AS stxdndistinct,  "
+	"                    sd.stxddependencies::text AS stxddependencies,  "
+	"                    ( "
+	"                        SELECT array_agg(mcvl) "
+	"                        FROM pg_catalog.pg_mcv_list_items(sd.stxdmcv) AS mcvl "
+	"                        WHERE sd.stxdmcv IS NOT NULL "
+	"                    ) AS stxdmcv "
+	"                FROM pg_catalog.pg_statistic_ext_data AS sd "
+	"                WHERE sd.stxoid = e.oid "
+	"            ) r "
+	"        ), "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_type AS t "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY ar.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_catalog.pg_class r "
+	"JOIN pg_catalog.pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_catalog.pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/*
+ * v10-v11 are like v12, but:
+ *     - MCV is gone
+ *     - remaining stats are stored on pg_statistic_ext
+ *     - pg_statistic_ext_data is gone
+ */
+
+const char *stats_export_ext_query_v10 =
+	"    jsonb_build_object( "
+	"        'server_version_num', current_setting('server_version_num'), "
+	"        'stxoid', e.oid, "
+	"        'reloid', r.oid, "
+	"        'stxname', e.stxname, "
+	"        'stxnspname', en.nspname, "
+	"        'relname', r.relname, "
+	"        'nspname', n.nspname, "
+	"        'stxkeys', e.stxkeys::text, "
+	"        'stxkind', e.stxkind::text, "
+	"        'stxndistinct', e.stxndistinct::text, "
+	"        'stxdependencies', e.stxdependencies::text, "
+	"        'types', "
+	"        ( "
+	"            SELECT array_agg(tr ORDER BY tr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    t.oid, "
+	"                    t.typname, "
+	"                    n.nspname "
+	"                FROM pg_catalog.pg_type AS t "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = t.typnamespace "
+	"                WHERE t.oid IN ( "
+	"                    SELECT a.atttypid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                ) "
+	"            ) AS tr "
+	"        ), "
+	"        'collations', "
+	"        ( "
+	"            SELECT array_agg(cr ORDER BY cr.oid) "
+	"            FROM ( "
+	"                SELECT "
+	"                    c.oid, "
+	"                    c.collname, "
+	"                    n.nspname  "
+	"                FROM pg_catalog.pg_collation AS c "
+	"                JOIN pg_catalog.pg_namespace AS n ON n.oid = c.collnamespace "
+	"                WHERE c.oid IN ( "
+	"                    SELECT a.attcollation AS oid "
+	"                    FROM pg_catalog.pg_attribute AS a "
+	"                    WHERE a.attrelid = r.oid "
+	"                    AND NOT a.attisdropped "
+	"                    AND a.attnum > 0 "
+	"                    ) "
+	"                ) AS cr "
+	"        ), "
+	"        'attributes',  "
+	"        ( "
+	"            SELECT array_agg(ar ORDER BY r.attnum) "
+	"            FROM ( "
+	"                SELECT "
+	"                    a.attnum, "
+	"                    a.attname, "
+	"                    a.atttypid, "
+	"                    a.attcollation "
+	"                FROM pg_catalog.pg_attribute AS a "
+	"                WHERE a.attrelid = r.oid "
+	"                AND NOT a.attisdropped "
+	"                AND a.attnum > 0 "
+	"            ) AS ar "
+	"        ) "
+	"    ) AS ext_stats_json "
+	"FROM pg_catalog.pg_class r "
+	"JOIN pg_catalog.pg_statistic_ext AS e ON e.stxrelid = r.oid "
+	"JOIN pg_catalog.pg_namespace AS en ON en.oid = e.stxnamespace "
+	"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace ";
+
+/*
+ * Return the pg_statitic export query fragment appropriate for the
+ * given server_version_num.
+ */
+const char *
+stats_export_rel_query(int server_version_num)
+{
+	if (server_version_num >= 120000)
+		return stats_export_rel_query_v12;
+	else if (server_version_num >= 100000)
+		return stats_export_rel_query_v10;
+	else
+		return NULL;
+}
+
+/*
+ * Return the pg_statitic_ext export query fragment appropriate for the
+ * given server_version_num.
+ */
+const char *
+stats_export_ext_query(int server_version_num)
+{
+	if (server_version_num >= 150000)
+		return stats_export_ext_query_v15;
+	else if (server_version_num >= 140000)
+		return stats_export_ext_query_v14;
+	else if (server_version_num >= 120000)
+		return stats_export_ext_query_v12;
+	else if (server_version_num >= 100000)
+		return stats_export_ext_query_v10;
+	else
+		return NULL;
+}
+
+/*
+ * Names cannot be null, must be regular strings
+ */
+#define is_quoted_name(s) \
+	(s != NULL) && \
+	((s[0] == '\'')) && \
+	(s[strlen(s)-1] == '\'')
+
+/*
+ * JSON strings can be NULL, and may extended format E'...' strings.
+ */
+#define is_quoted_json(s) \
+	(s == NULL) || \
+	(((s[0] == '\'') || ((s[0] == 'E' && s[1] == '\''))) && \
+	 (s[strlen(s)-1] == '\''))
+
+/*
+ * Print the SQL statement to import statistics to a given relation.
+ */
+void
+stats_export_print_rel_import(FILE *outf,
+							  const char *nspname_literal,
+							  const char *relname_literal,
+							  const char *stats_json_literal,
+							  bool validate,
+							  bool require_match)
+{
+	Assert(is_quoted_name(nspname_literal));
+	Assert(is_quoted_name(relname_literal));
+	Assert(is_quoted_json(stats_json_literal));
+
+	fprintf(outf,
+			"SELECT pg_catalog.pg_import_rel_stats(r.oid, %s::jsonb, %s, %s) "
+			"FROM pg_catalog.pg_catalog.pg_class AS r "
+			"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace "
+			"WHERE n.nspname = %s "
+			"AND r.relname = %s;\n\n",
+			(stats_json_literal != NULL) ? stats_json_literal : "NULL",
+			(validate) ? "true" : "false",
+			(require_match) ? "true" : "false",
+			nspname_literal,
+			relname_literal);
+}
+
+/*
+ * Print the SQL statement to import statistics to a given statistics object.
+ */
+void
+stats_export_print_ext_import(FILE *outf,
+							  const char *nspname_literal,
+							  const char *relname_literal,
+							  const char *stxname_literal,
+							  const char *ext_stats_json_literal,
+							  bool validate,
+							  bool require_match)
+{
+	Assert(is_quoted_name(nspname_literal));
+	Assert(is_quoted_name(relname_literal));
+	Assert(is_quoted_name(stxname_literal));
+	Assert(is_quoted_json(ext_stats_json_literal));
+
+	fprintf(outf,
+			"SELECT pg_catalog.pg_import_ext_stats(e.oid, %s::jsonb, %s, %s) "
+			"FROM pg_catalog.pg_class r "
+			"JOIN pg_catalog.pg_statistic_ext AS e ON e.stxrelid = r.oid "
+			"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace "
+			"WHERE n.nspname = %s "
+			"AND r.relname = %s "
+			"AND e.stxname = %s;\n\n",
+			(ext_stats_json_literal != NULL) ? ext_stats_json_literal : "NULL",
+			(validate) ? "true" : "false",
+			(require_match) ? "true" : "false",
+			nspname_literal,
+			relname_literal,
+			stxname_literal);
+}
-- 
2.43.2

From fa020383ac1811fb02997b53f0551a8d3ae26329 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Tue, 20 Feb 2024 01:14:54 -0500
Subject: [PATCH v6 4/4] Add pg_export_stats.

This is a command-line utility that connects to a database and exports
statistics from all user relations and user statistics objects, printing
SQL statements designed to re-import those statistics into a like-named
object.
---
 src/fe_utils/stats_export.c       |   2 +-
 src/bin/scripts/.gitignore        |   1 +
 src/bin/scripts/Makefile          |   3 +-
 src/bin/scripts/pg_export_stats.c | 267 ++++++++++++++++++++++++++++++
 4 files changed, 271 insertions(+), 2 deletions(-)
 create mode 100644 src/bin/scripts/pg_export_stats.c

diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
index 1815793c9d..09b4eb240d 100644
--- a/src/fe_utils/stats_export.c
+++ b/src/fe_utils/stats_export.c
@@ -835,7 +835,7 @@ stats_export_print_rel_import(FILE *outf,
 
 	fprintf(outf,
 			"SELECT pg_catalog.pg_import_rel_stats(r.oid, %s::jsonb, %s, %s) "
-			"FROM pg_catalog.pg_catalog.pg_class AS r "
+			"FROM pg_catalog.pg_class AS r "
 			"JOIN pg_catalog.pg_namespace AS n ON n.oid = r.relnamespace "
 			"WHERE n.nspname = %s "
 			"AND r.relname = %s;\n\n",
diff --git a/src/bin/scripts/.gitignore b/src/bin/scripts/.gitignore
index 0f23fe0004..76704a3ad4 100644
--- a/src/bin/scripts/.gitignore
+++ b/src/bin/scripts/.gitignore
@@ -6,5 +6,6 @@
 /reindexdb
 /vacuumdb
 /pg_isready
+/pg_export_stats
 
 /tmp_check/
diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile
index 9633c99136..dd54faaf2a 100644
--- a/src/bin/scripts/Makefile
+++ b/src/bin/scripts/Makefile
@@ -16,7 +16,7 @@ subdir = src/bin/scripts
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready
+PROGRAMS = createdb createuser dropdb dropuser clusterdb vacuumdb reindexdb pg_isready pg_export_stats
 
 override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
 LDFLAGS_INTERNAL += -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport)
@@ -41,6 +41,7 @@ install: all installdirs
 	$(INSTALL_PROGRAM) vacuumdb$(X)   '$(DESTDIR)$(bindir)'/vacuumdb$(X)
 	$(INSTALL_PROGRAM) reindexdb$(X)  '$(DESTDIR)$(bindir)'/reindexdb$(X)
 	$(INSTALL_PROGRAM) pg_isready$(X) '$(DESTDIR)$(bindir)'/pg_isready$(X)
+	$(INSTALL_PROGRAM) pg_export_stats$(X) '$(DESTDIR)$(bindir)'/pg_export_stats$(X)
 
 installdirs:
 	$(MKDIR_P) '$(DESTDIR)$(bindir)'
diff --git a/src/bin/scripts/pg_export_stats.c b/src/bin/scripts/pg_export_stats.c
new file mode 100644
index 0000000000..7fce1ef515
--- /dev/null
+++ b/src/bin/scripts/pg_export_stats.c
@@ -0,0 +1,267 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_export_stats
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/scripts/pg_export_stats.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "common.h"
+#include "common/logging.h"
+#include "fe_utils/cancel.h"
+#include "fe_utils/option_utils.h"
+#include "fe_utils/query_utils.h"
+#include "fe_utils/simple_list.h"
+#include "fe_utils/stats_export.h"
+#include "fe_utils/string_utils.h"
+
+static void help(const char *progname);
+
+int
+main(int argc, char *argv[])
+{
+	static struct option long_options[] = {
+		{"host", required_argument, NULL, 'h'},
+		{"port", required_argument, NULL, 'p'},
+		{"username", required_argument, NULL, 'U'},
+		{"no-password", no_argument, NULL, 'w'},
+		{"password", no_argument, NULL, 'W'},
+		{"echo", no_argument, NULL, 'e'},
+		{"dbname", required_argument, NULL, 'd'},
+		{"validate", no_argument, NULL, 'v'},
+		{"require-match", no_argument, NULL, 'm'},
+		{NULL, 0, NULL, 0}
+	};
+
+	const char *progname;
+	int			optindex;
+	int			c;
+
+	bool		validate = false;
+	bool		require_match = false;
+	const char *dbname = NULL;
+	char	   *host = NULL;
+	char	   *port = NULL;
+	char	   *username = NULL;
+	enum trivalue prompt_password = TRI_DEFAULT;
+	ConnParams	cparams;
+	bool		echo = false;
+
+	PQExpBufferData sql;
+
+	PGconn	   *conn;
+	int			server_version_num;
+
+	PGresult   *result;
+
+	ExecStatusType result_status;
+
+	pg_logging_init(argv[0]);
+	progname = get_progname(argv[0]);
+	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
+
+	handle_help_version_opts(argc, argv, "pg_export_stats", help);
+
+	while ((c = getopt_long(argc, argv, "d:eh:mp:U:vwW", long_options, &optindex)) != -1)
+	{
+		switch (c)
+		{
+			case 'd':
+				dbname = pg_strdup(optarg);
+				break;
+			case 'e':
+				echo = true;
+				break;
+			case 'h':
+				host = pg_strdup(optarg);
+				break;
+			case 'm':
+				require_match = true;
+				break;
+			case 'p':
+				port = pg_strdup(optarg);
+				break;
+			case 'U':
+				username = pg_strdup(optarg);
+				break;
+			case 'v':
+				validate = true;
+				break;
+			case 'w':
+				prompt_password = TRI_NO;
+				break;
+			case 'W':
+				prompt_password = TRI_YES;
+				break;
+			default:
+				/* getopt_long already emitted a complaint */
+				pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+				exit(1);
+		}
+	}
+
+	/*
+	 * Non-option argument specifies database name as long as it wasn't
+	 * already specified with -d / --dbname
+	 */
+	if (optind < argc && dbname == NULL)
+	{
+		dbname = argv[optind];
+		optind++;
+	}
+
+	if (optind < argc)
+	{
+		pg_log_error("too many command-line arguments (first is \"%s\")",
+					 argv[optind]);
+		pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+		exit(1);
+	}
+
+	/* fill cparams except for dbname, which is set below */
+	cparams.pghost = host;
+	cparams.pgport = port;
+	cparams.pguser = username;
+	cparams.prompt_password = prompt_password;
+	cparams.override_dbname = NULL;
+
+	setup_cancel_handler(NULL);
+
+	if (dbname == NULL)
+	{
+		if (getenv("PGDATABASE"))
+			dbname = getenv("PGDATABASE");
+		else if (getenv("PGUSER"))
+			dbname = getenv("PGUSER");
+		else
+			dbname = get_user_name_or_exit(progname);
+	}
+
+	cparams.dbname = dbname;
+
+	conn = connectDatabase(&cparams, progname, echo, false, true);
+
+	server_version_num = PQserverVersion(conn);
+
+	initPQExpBuffer(&sql);
+
+	/*
+	 * Query catalog for relations, export statistics from each of them,
+	 * and generate a SQL statement to re-import those statistics.
+	 */
+	appendPQExpBufferStr(&sql,
+		"SELECT quote_literal(b.nspname), quote_literal(b.relname), "
+		"       quote_literal(b.stats_json) "
+		"FROM ( SELECT n.nspname, r.relname, ");
+
+	appendPQExpBufferStr(&sql, stats_export_rel_query(server_version_num));
+
+	appendPQExpBufferStr(&sql,
+		"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+		"AND r.relpersistence = 'p' "
+		"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') "
+		"ORDER BY n.nspname, r.relname"
+		") AS b");
+
+	if (echo)
+		printf("%s\n", sql.data);
+
+	result = PQexec(conn, sql.data);
+	result_status = PQresultStatus(result);
+
+	if (result_status != PGRES_TUPLES_OK)
+		pg_fatal("malformed catalog query: %s", PQerrorMessage(conn));
+	else
+	{
+		int nrows = PQntuples(result);
+		int i;
+
+		for (i = 0; i < nrows; i++)
+			stats_export_print_rel_import(stdout,
+										  PQgetvalue(result, i, 0),
+										  PQgetvalue(result, i, 1),
+										  PQgetvalue(result, i, 2),
+										  validate,
+										  require_match);
+	}
+
+	PQclear(result);
+	resetPQExpBuffer(&sql);
+
+	/*
+	 * Query catalog for statistics objects, export statistics from each of
+	 * them, and generate a SQL statement to re-import those statistics.
+	 */
+	appendPQExpBufferStr(&sql,
+		"SELECT quote_literal(b.nspname), quote_literal(b.relname), "
+		"       quote_literal(b.stxname), quote_literal(b.ext_stats_json) "
+		"FROM ( SELECT n.nspname, r.relname, e.stxname, ");
+
+	appendPQExpBufferStr(&sql, stats_export_ext_query(server_version_num));
+
+	appendPQExpBufferStr(&sql,
+		"WHERE r.relkind IN ('r', 'm', 'f', 'p', 'i') "
+		"AND r.relpersistence = 'p' "
+		"AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') "
+		"ORDER BY n.nspname, r.relname, e.stxname "
+		") AS b ");
+
+	if (echo)
+		printf("%s\n", sql.data);
+
+	result = PQexec(conn, sql.data);
+	result_status = PQresultStatus(result);
+
+	if (result_status != PGRES_TUPLES_OK)
+		pg_fatal("malformed catalog query: %s", PQerrorMessage(conn));
+	else
+	{
+		int nrows = PQntuples(result);
+		int i;
+
+		for (i = 0; i < nrows; i++)
+			stats_export_print_ext_import(stdout,
+										  PQgetvalue(result, i, 0),
+										  PQgetvalue(result, i, 1),
+										  PQgetvalue(result, i, 2),
+										  PQgetvalue(result, i, 3),
+										  validate,
+										  require_match);
+	}
+
+	PQclear(result);
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+	exit(0);
+}
+
+
+static void
+help(const char *progname)
+{
+	printf(_("%s export statistics for all objects in a database.\n\n"), progname);
+	printf(_("Usage:\n"));
+	printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
+	printf(_("\nOptions:\n"));
+	printf(_("  -d, --dbname=DBNAME       database to export\n"));
+	printf(_("  -e, --echo                show the commands being sent to the server\n"));
+	printf(_("  -V, --version             output version information, then exit\n"));
+	printf(_("  -?, --help                show this help, then exit\n"));
+	printf(_("  -v, --validate            Import calls generated should set the validate flag\n"));
+	printf(_("  -m, --require-match       Import calls generated should set the require_match flag\n"));
+	printf(_("\nConnection options:\n"));
+	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));
+	printf(_("  -p, --port=PORT           database server port\n"));
+	printf(_("  -U, --username=USERNAME   user name to connect as\n"));
+	printf(_("  -w, --no-password         never prompt for password\n"));
+	printf(_("  -W, --password            force password prompt\n"));
+	printf(_("  --maintenance-db=DBNAME   alternate maintenance database\n"));
+	printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+	printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
+}
-- 
2.43.2

From 9bc7200b8a67efefe20453e0c48aed8a0a5f62f8 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 7 Mar 2024 22:18:48 -0500
Subject: [PATCH v7] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics would have to
make sense in the context of the new relation. Typecasts for stavaluesN
parameters may fail if the destination column is not of the same type as
the source column.

The parameters of pg_set_attribute_stats identify the attribute by name
rather than by attnum. This is intentional because the column order may
be different in situations other than binary upgrades. For example,
dropped columns do not carry over in a restore.

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  19 +-
 src/include/statistics/statistics.h           |   3 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 360 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 211 ++++++++++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 198 ++++++++++
 doc/src/sgml/func.sgml                        |  89 +++++
 9 files changed, 882 insertions(+), 4 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 291ed876fc..d12b6e3ca3 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -8818,7 +8818,6 @@
 { oid => '3813', descr => 'generate XML text node',
   proname => 'xmltext', proisstrict => 't', prorettype => 'xml',
   proargtypes => 'text', prosrc => 'xmltext' },
-
 { oid => '2923', descr => 'map table contents to XML',
   proname => 'table_to_xml', procost => '100', provolatile => 's',
   proparallel => 'r', prorettype => 'xml',
@@ -12163,8 +12162,24 @@
 
 # GiST stratnum implementations
 { oid => '8047', descr => 'GiST support',
-  proname => 'gist_stratnum_identity', prorettype => 'int2',
+  proname => 'gist_stratnum_identity',prorettype => 'int2',
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid float4 int4',
+  proargnames => '{relation,reltuples,relpages}',
+  prosrc => 'pg_set_relation_stats' },
+
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid name bool float4 int4 float4 int2 int2 int2 int2 int2 _float4 _float4 _float4 _float4 _float4 text text text text text',
+  proargnames => '{relation,attname,stainherit,stanullfrac,stawidth,stadistinct,stakind1,stakind2,stakind3,stakind4,stakind5,stanumbers1,stanumbers2,stanumbers3,stanumbers4,stanumbers5,stavalues1,stavalues2,stavalues3,stavalues4,stavalues5}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..73d3b541dd 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,7 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
+
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..999aebdfa9
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,360 @@
+/*------------------------------------------------------------------------- * * statistics.c *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * pg_set_relation_stats(relation Oid, reltuples double, relpages int)
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	const char *param_names[] = {
+		"relation",
+		"reltuples",
+		"relpages",
+	};
+
+	Oid				relid;
+	Relation		rel;
+	HeapTuple		ctup;
+	Form_pg_class	pgcform;
+
+	for (int i = 0; i <= 2; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(0);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+			 relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+	pgcform->reltuples = PG_GETARG_FLOAT4(1);
+	pgcform->relpages = PG_GETARG_INT32(2);
+
+	heap_inplace_update(rel, ctup);
+
+	table_close(rel, ShareUpdateExclusiveLock);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Import statistics for a given relation attribute
+ *
+ * pg_set_attribute_stats(relation Oid, attname name, stainherit bool,
+ *                        stanullfrac float4, stawidth int, stadistinct float4,
+ *                        stakind1 int2, stakind2 int2, stakind3 int3,
+ *                        stakind4 int2, stakind5 int2, stanumbers1 float4[],
+ *                        stanumbers2 float4[], stanumbers3 float4[],
+ *                        stanumbers4 float4[], stanumbers5 float4[],
+ *                        stanumbers1 float4[], stanumbers2 float4[],
+ *                        stanumbers3 float4[], stanumbers4 float4[],
+ *                        stanumbers5 float4[], stavalues1 text,
+ *                        stavalues2 text, stavalues3 text,
+ *                        stavalues4 text, stavalues5 text);
+ *
+ *
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum {
+		P_RELATION = 0,
+		P_ATTNAME,
+		P_STAINHERIT,
+		P_STANULLFRAC,
+		P_STAWIDTH,
+		P_STADISTINCT,
+		P_STAKIND1,
+		P_STAKIND2,
+		P_STAKIND3,
+		P_STAKIND4,
+		P_STAKIND5,
+		P_STANUMBERS1,
+		P_STANUMBERS2,
+		P_STANUMBERS3,
+		P_STANUMBERS4,
+		P_STANUMBERS5,
+		P_STAVALUES1,
+		P_STAVALUES2,
+		P_STAVALUES3,
+		P_STAVALUES4,
+		P_STAVALUES5,
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *required_param_names[] = {
+		"relation",
+		"attname",
+		"stainherit",
+		"stanullfrac",
+		"stawidth",
+		"stadistinct",
+		"stakind1",
+		"stakind2",
+		"stakind3",
+		"stakind4",
+		"stakind5",
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+	HeapTuple	tuple;
+
+	Oid		typid;
+	int32	typmod;
+	Oid		typcoll;
+	Oid 	eqopr;
+	Oid 	ltopr;
+	Oid		basetypid;
+	Oid 	baseeqopr;
+	Oid 	baseltopr;
+
+	float4	stanullfrac;
+	int		stawidth;
+
+	Datum	values[Natts_pg_statistic] = { 0 };
+	bool	nulls[Natts_pg_statistic] = { false };
+
+	Relation			sd;
+	HeapTuple			oldtup;
+	CatalogIndexState	indstate;
+	HeapTuple			stup;
+	Form_pg_attribute	attr;
+
+	for (int i = P_RELATION; i <= P_STAKIND5; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", required_param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+	tuple = SearchSysCache2(ATTNAME,
+							ObjectIdGetDatum(relid),
+							NameGetDatum(attname));
+
+	if (!HeapTupleIsValid(tuple))
+	{
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	attr = (Form_pg_attribute) GETSTRUCT(tuple);
+	if (attr->attisdropped)
+	{
+		ReleaseSysCache(tuple);
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * If this relation is an index and that index has expressions in
+	 * it, and the attnum specified is known to be an expression, then
+	 * we must walk the list attributes up to the specified attnum
+	 * to get the right expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+				|| (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+			&& (rel->rd_indexprs != NIL)
+			&& (rel->rd_index->indkey.values[attr->attnum-1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	stanullfrac = PG_GETARG_FLOAT4(P_STANULLFRAC);
+	if ((stanullfrac < 0.0) || (stanullfrac > 1.0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stanullfrac %f is out of range 0.0 to 1.0", stanullfrac)));
+
+	stawidth = PG_GETARG_INT32(P_STAWIDTH);
+	if (stawidth < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stawidth %d must be >= 0", stawidth)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_STAINHERIT);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_STANULLFRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_STAWIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_STADISTINCT);
+
+	/* The remaining fields are all parallel arrays, so we iterate over them */
+	for (int k = 0; k < 5; k++)
+	{
+		int16	kind = PG_GETARG_INT16(P_STAKIND1 + k);
+		Oid		opoid;
+		Oid		colloid;
+
+		switch(kind) {
+			case 0:
+				opoid = InvalidOid;
+				colloid = InvalidOid;
+				break;
+			case STATISTIC_KIND_MCV:
+				opoid = eqopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_HISTOGRAM:
+			case STATISTIC_KIND_CORRELATION:
+			case STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM:
+			case STATISTIC_KIND_BOUNDS_HISTOGRAM:
+				opoid = ltopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_MCELEM:
+			case STATISTIC_KIND_DECHIST:
+				opoid = baseeqopr;
+				colloid = typcoll;
+				break;
+			default:
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("stakind%d = %d is out of the range 0 to %d", k + 1,
+								kind, STATISTIC_KIND_BOUNDS_HISTOGRAM)));
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] = PG_GETARG_DATUM(P_STAKIND1 + k);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(opoid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(colloid);
+
+		if (PG_ARGISNULL(P_STANUMBERS1 + k))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] = PG_GETARG_DATUM(P_STANUMBERS1 + k);
+
+		if (PG_ARGISNULL(P_STAVALUES1 + k))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+		{
+			char   *s = TextDatumGetCString(PG_GETARG_DATUM(P_STAVALUES1 + k));
+			FmgrInfo finfo;
+
+			fmgr_info(F_ARRAY_IN, &finfo);
+
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				FunctionCall3(&finfo, CStringGetDatum(s), ObjectIdGetDatum(basetypid),
+							  Int32GetDatum(typmod));
+
+			pfree(s);
+		}
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_STAINHERIT));
+
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool replaces[Natts_pg_statistic] = { true };
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(tuple);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..50ce86693a
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,211 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+SELECT reltuples, relpages FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages 
+-----------+----------
+        -1 |        0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000);
+ pg_set_relation_stats 
+-----------------------
+ t
+(1 row)
+
+SELECT reltuples, relpages FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages 
+-----------+----------
+       3.6 |    15000
+(1 row)
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         4
+ test_clone   |         4
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..75c9d130b1
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,198 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+SELECT reltuples, relpages FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000);
+
+SELECT reltuples, relpages FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+-- copy stats from test to test_clone and is_odd to is_odd_clone
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+           || 'relation => %L::regclass, attname => %L::name, '
+           || 'stainherit => %L::boolean, stanullfrac => %s::real, '
+           || 'stawidth => %s::integer, stadistinct => %s::real, '
+           || 'stakind1 => %s::smallint, stakind2 => %s::smallint, '
+           || 'stakind3 => %s::smallint, stakind4 => %s::smallint, '
+           || 'stakind5 => %s::smallint, '
+           || 'stanumbers1 => %L::real[], stanumbers2 => %L::real[], '
+           || 'stanumbers3 => %L::real[], stanumbers4 => %L::real[], '
+           || 'stanumbers5 => %L::real[], '
+           || 'stavalues1 => %L::text, stavalues2 => %L::text, '
+           || 'stavalues3 => %L::text, stavalues4 => %L::text, '
+           || 'stavalues5 => %L::text)',
+        'stats_export_import.' || c.relname || '_clone', a.attname,
+        s.stainherit, s.stanullfrac,
+        s.stawidth, s.stadistinct,
+        s.stakind1, s.stakind2, s.stakind3,
+        s.stakind4, s.stakind5,
+        s.stanumbers1, s.stanumbers2,
+        s.stanumbers3, s.stanumbers4,
+        s.stanumbers5,
+        s.stavalues1::text, s.stavalues2::text, s.stavalues3::text,
+        s.stavalues4::text, s.stavalues5::text)
+FROM pg_class AS c
+JOIN pg_attribute a ON a.attrelid = c.oid
+JOIN pg_statistic s ON s.starelid = a.attrelid AND s.staattnum = a.attnum
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 0bb7aeb40e..3e88aec27f 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28739,6 +28739,95 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> ( <parameter>relation</parameter> <type>regclass</type>, <parameter>reltuples</parameter> <type>float4</type>, <parameter>relpages</parameter> <type>integer</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield> and <structfield>relpages</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>attname</parameter> <type>name</type>,
+         <parameter>stainherit</parameter> <type>boolean</type>,
+         <parameter>stanullfrac</parameter> <type>real</type>,
+         <parameter>stawidth</parameter> <type>integer</type>,
+         <parameter>stadistinct</parameter> <type>real</type>,
+         <parameter>stakind1</parameter> <type>smallint</type>,
+         <parameter>stakind2</parameter> <type>smallint</type>,
+         <parameter>stakind3</parameter> <type>smallint</type>,
+         <parameter>stakind4</parameter> <type>smallint</type>,
+         <parameter>stakind5</parameter> <type>smallint</type>,
+         <parameter>stanumbers1</parameter> <type>real[]</type>,
+         <parameter>stanumbers2</parameter> <type>real[]</type>,
+         <parameter>stanumbers3</parameter> <type>real[]</type>,
+         <parameter>stanumbers4</parameter> <type>real[]</type>,
+         <parameter>stanumbers5</parameter> <type>real[]</type>,
+         <parameter>stavalues1</parameter> <type>text</type>,
+         <parameter>stavalues2</parameter> <type>text</type>,
+         <parameter>stavalues3</parameter> <type>text</type>,
+         <parameter>stavalues4</parameter> <type>text</type>,
+         <parameter>stavalues5</parameter> <type>text</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter> and <parameter>attname</parameter>.
+        The values for fields <structfield>staopN</structfield> and
+        <structfield>stacollN</structfield> are derived from the
+        <structname>pg_attribute</structname> row and the corresponding
+        <parameter>stakindN</parameter> value.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From bdfde573f4f79770439a1455c1cb337701eb20dc Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Mon, 11 Mar 2024 14:18:39 -0400
Subject: [PATCH v8] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics would have to
make sense in the context of the new relation. Typecasts for stavaluesN
parameters may fail if the destination column is not of the same type as
the source column.

The parameters of pg_set_attribute_stats identify the attribute by name
rather than by attnum. This is intentional because the column order may
be different in situations other than binary upgrades. For example,
dropped columns do not carry over in a restore.

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  15 +
 src/include/statistics/statistics.h           |   2 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 399 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 211 +++++++++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 198 +++++++++
 doc/src/sgml/func.sgml                        |  95 +++++
 9 files changed, 924 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 291ed876fc..9fa685e1ba 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12167,4 +12167,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid float4 int4 int4',
+  proargnames => '{relation,reltuples,relpages,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid name bool float4 int4 float4 int2 int2 int2 int2 int2 _float4 _float4 _float4 _float4 _float4 text text text text text',
+  proargnames => '{relation,attname,stainherit,stanullfrac,stawidth,stadistinct,stakind1,stakind2,stakind3,stakind4,stakind5,stanumbers1,stanumbers2,stanumbers3,stanumbers4,stanumbers5,stavalues1,stavalues2,stavalues3,stavalues4,stavalues5}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..78b4e728fb
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,399 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELTUPLES,			/* float4 */
+		P_RELPAGES,				/* int */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* The function is strict, but just to be safe */
+	Assert(!PG_ARGISNULL(P_RELATION) && !PG_ARGISNULL(P_RELTUPLES) &&
+		   !PG_ARGISNULL(P_RELPAGES) && !PG_ARGISNULL(P_RELALLVISIBLE));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "pg_class entry for relid %u vanished during statistics import",
+			 relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Do not update pg_class unless there is no meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, ShareUpdateExclusiveLock);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * This function will return NULL if either the relation or the attname are
+ * NULL.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will return false. If there is a matching attribute but the
+ * attribute is dropped, then function will return false.
+ *
+ * The function does not specify values for staopN or stacollN parameters
+ * because those values are determined by the corresponding stakindN value and
+ * the attribute's underlying datatype.
+ *
+ * The stavaluesN parameters are text values, and must be a valid input string
+ * for an array of the basetype of the attribute. Any error generated by the
+ * array_in() function will in turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_STAINHERIT,			/* bool */
+		P_STANULLFRAC,			/* float4 */
+		P_STAWIDTH,				/* int32 */
+		P_STADISTINCT,			/* float4 */
+		P_STAKIND1,				/* int16 */
+		P_STAKIND2,				/* int16 */
+		P_STAKIND3,				/* int16 */
+		P_STAKIND4,				/* int16 */
+		P_STAKIND5,				/* int16 */
+		P_STANUMBERS1,			/* float4[], null */
+		P_STANUMBERS2,			/* float4[], null */
+		P_STANUMBERS3,			/* float4[], null */
+		P_STANUMBERS4,			/* float4[], null */
+		P_STANUMBERS5,			/* float4[], null */
+		P_STAVALUES1,			/* text, null */
+		P_STAVALUES2,			/* text, null */
+		P_STAVALUES3,			/* text, null */
+		P_STAVALUES4,			/* text, null */
+		P_STAVALUES5,			/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *required_param_names[] = {
+		"relation",
+		"attname",
+		"stainherit",
+		"stanullfrac",
+		"stawidth",
+		"stadistinct",
+		"stakind1",
+		"stakind2",
+		"stakind3",
+		"stakind4",
+		"stakind5",
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+	HeapTuple	tuple;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	float4		stanullfrac;
+	int			stawidth;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+
+	/*
+	 * This function is pseudo-strct in that a NULL for the relation oid or
+	 * the attribute name results is a NULL return value.
+	 */
+	if (PG_ARGISNULL(P_RELATION) || PG_ARGISNULL(P_ATTNAME))
+		PG_RETURN_NULL();
+
+	for (int i = P_STAINHERIT; i <= P_STAKIND5; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", required_param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+	tuple = SearchSysCache2(ATTNAME,
+							ObjectIdGetDatum(relid),
+							NameGetDatum(attname));
+
+	if (!HeapTupleIsValid(tuple))
+	{
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	attr = (Form_pg_attribute) GETSTRUCT(tuple);
+	if (attr->attisdropped)
+	{
+		ReleaseSysCache(tuple);
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	stanullfrac = PG_GETARG_FLOAT4(P_STANULLFRAC);
+	if ((stanullfrac < 0.0) || (stanullfrac > 1.0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stanullfrac %f is out of range 0.0 to 1.0", stanullfrac)));
+
+	stawidth = PG_GETARG_INT32(P_STAWIDTH);
+	if (stawidth < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stawidth %d must be >= 0", stawidth)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_STAINHERIT);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_STANULLFRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_STAWIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_STADISTINCT);
+
+	/* The remaining fields are all parallel arrays, so we iterate over them */
+	for (int k = 0; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		int16		kind = PG_GETARG_INT16(P_STAKIND1 + k);
+		Oid			opoid;
+		Oid			colloid;
+
+		switch (kind)
+		{
+			case 0:
+				opoid = InvalidOid;
+				colloid = InvalidOid;
+				break;
+			case STATISTIC_KIND_MCV:
+				opoid = eqopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_HISTOGRAM:
+			case STATISTIC_KIND_CORRELATION:
+			case STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM:
+			case STATISTIC_KIND_BOUNDS_HISTOGRAM:
+				opoid = ltopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_MCELEM:
+			case STATISTIC_KIND_DECHIST:
+				opoid = baseeqopr;
+				colloid = typcoll;
+				break;
+			default:
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("stakind%d = %d is out of the range 0 to %d", k + 1,
+								kind, STATISTIC_KIND_BOUNDS_HISTOGRAM)));
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] = PG_GETARG_DATUM(P_STAKIND1 + k);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(opoid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(colloid);
+
+		if (PG_ARGISNULL(P_STANUMBERS1 + k))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] = PG_GETARG_DATUM(P_STANUMBERS1 + k);
+
+		if (PG_ARGISNULL(P_STAVALUES1 + k))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+		{
+			char	   *s = TextDatumGetCString(PG_GETARG_DATUM(P_STAVALUES1 + k));
+			FmgrInfo	finfo;
+
+			fmgr_info(F_ARRAY_IN, &finfo);
+
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				FunctionCall3(&finfo, CStringGetDatum(s), ObjectIdGetDatum(basetypid),
+							  Int32GetDatum(typmod));
+
+			pfree(s);
+		}
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_STAINHERIT));
+
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic] = {true};
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, RowExclusiveLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(tuple);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..56679c2615
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,211 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+        -1 |        0 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000, 999);
+ pg_set_relation_stats 
+-----------------------
+ t
+(1 row)
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+       3.6 |    15000 |           999
+(1 row)
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         4
+ test_clone   |         4
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..01087c9aee
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,198 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000, 999);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+-- copy stats from test to test_clone and is_odd to is_odd_clone
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+           || 'relation => %L::regclass, attname => %L::name, '
+           || 'stainherit => %L::boolean, stanullfrac => %s::real, '
+           || 'stawidth => %s::integer, stadistinct => %s::real, '
+           || 'stakind1 => %s::smallint, stakind2 => %s::smallint, '
+           || 'stakind3 => %s::smallint, stakind4 => %s::smallint, '
+           || 'stakind5 => %s::smallint, '
+           || 'stanumbers1 => %L::real[], stanumbers2 => %L::real[], '
+           || 'stanumbers3 => %L::real[], stanumbers4 => %L::real[], '
+           || 'stanumbers5 => %L::real[], '
+           || 'stavalues1 => %L::text, stavalues2 => %L::text, '
+           || 'stavalues3 => %L::text, stavalues4 => %L::text, '
+           || 'stavalues5 => %L::text)',
+        'stats_export_import.' || c.relname || '_clone', a.attname,
+        s.stainherit, s.stanullfrac,
+        s.stawidth, s.stadistinct,
+        s.stakind1, s.stakind2, s.stakind3,
+        s.stakind4, s.stakind5,
+        s.stanumbers1, s.stanumbers2,
+        s.stanumbers3, s.stanumbers4,
+        s.stanumbers5,
+        s.stavalues1::text, s.stavalues2::text, s.stavalues3::text,
+        s.stavalues4::text, s.stavalues5::text)
+FROM pg_class AS c
+JOIN pg_attribute a ON a.attrelid = c.oid
+JOIN pg_statistic s ON s.starelid = a.attrelid AND s.staattnum = a.attnum
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 0bb7aeb40e..76774cad18 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28739,6 +28739,101 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>reltuples</parameter> <type>float4</type>,
+         <parameter>relpages</parameter> <type>integer</type> )
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>attname</parameter> <type>name</type>,
+         <parameter>stainherit</parameter> <type>boolean</type>,
+         <parameter>stanullfrac</parameter> <type>real</type>,
+         <parameter>stawidth</parameter> <type>integer</type>,
+         <parameter>stadistinct</parameter> <type>real</type>,
+         <parameter>stakind1</parameter> <type>smallint</type>,
+         <parameter>stakind2</parameter> <type>smallint</type>,
+         <parameter>stakind3</parameter> <type>smallint</type>,
+         <parameter>stakind4</parameter> <type>smallint</type>,
+         <parameter>stakind5</parameter> <type>smallint</type>,
+         <parameter>stanumbers1</parameter> <type>real[]</type>,
+         <parameter>stanumbers2</parameter> <type>real[]</type>,
+         <parameter>stanumbers3</parameter> <type>real[]</type>,
+         <parameter>stanumbers4</parameter> <type>real[]</type>,
+         <parameter>stanumbers5</parameter> <type>real[]</type>,
+         <parameter>stavalues1</parameter> <type>text</type>,
+         <parameter>stavalues2</parameter> <type>text</type>,
+         <parameter>stavalues3</parameter> <type>text</type>,
+         <parameter>stavalues4</parameter> <type>text</type>,
+         <parameter>stavalues5</parameter> <type>text</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter> and <parameter>attname</parameter>.
+        The values for fields <structfield>staopN</structfield> and
+        <structfield>stacollN</structfield> are derived from the
+        <structname>pg_attribute</structname> row and the corresponding
+        <parameter>stakindN</parameter> value.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From bf291e323fc01215264d41b75d579c11bd22d2ec Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Mon, 11 Mar 2024 14:18:39 -0400
Subject: [PATCH v9 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics would have to
make sense in the context of the new relation. Typecasts for stavaluesN
parameters may fail if the destination column is not of the same type as
the source column.

The parameters of pg_set_attribute_stats identify the attribute by name
rather than by attnum. This is intentional because the column order may
be different in situations other than binary upgrades. For example,
dropped columns do not carry over in a restore.

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  15 +
 src/include/statistics/statistics.h           |   2 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 410 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 211 +++++++++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 198 +++++++++
 doc/src/sgml/func.sgml                        |  95 ++++
 9 files changed, 935 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 700f7daf7b..a726451a6f 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12170,4 +12170,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid float4 int4 int4',
+  proargnames => '{relation,reltuples,relpages,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid name bool float4 int4 float4 int2 int2 int2 int2 int2 _float4 _float4 _float4 _float4 _float4 text text text text text',
+  proargnames => '{relation,attname,stainherit,stanullfrac,stawidth,stadistinct,stakind1,stakind2,stakind3,stakind4,stakind5,stanumbers1,stanumbers2,stanumbers3,stanumbers4,stanumbers5,stavalues1,stavalues2,stavalues3,stavalues4,stavalues5}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..c005902171
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,410 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELTUPLES,			/* float4 */
+		P_RELPAGES,				/* int */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* The function is strict, but just to be safe */
+	Assert(!PG_ARGISNULL(P_RELATION) && !PG_ARGISNULL(P_RELTUPLES) &&
+		   !PG_ARGISNULL(P_RELPAGES) && !PG_ARGISNULL(P_RELALLVISIBLE));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	/*
+	 * TODO: choose an error code appropriate for this situation.
+	 * Canidates are:
+	 * ERRCODE_INVALID_CATALOG_NAME
+	 * ERRCODE_UNDEFINED_TABLE
+	 * ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE
+	 * ERRCODE_OBJECT_IN_USE
+	 * ERRCODE_SYSTEM_ERROR
+	 * ERRCODE_INTERNAL_ERROR
+	 */
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * This function will return NULL if either the relation or the attname are
+ * NULL.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will return false. If there is a matching attribute but the
+ * attribute is dropped, then function will return false.
+ *
+ * The function does not specify values for staopN or stacollN parameters
+ * because those values are determined by the corresponding stakindN value and
+ * the attribute's underlying datatype.
+ *
+ * The stavaluesN parameters are text values, and must be a valid input string
+ * for an array of the basetype of the attribute. Any error generated by the
+ * array_in() function will in turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_STAINHERIT,			/* bool */
+		P_STANULLFRAC,			/* float4 */
+		P_STAWIDTH,				/* int32 */
+		P_STADISTINCT,			/* float4 */
+		P_STAKIND1,				/* int16 */
+		P_STAKIND2,				/* int16 */
+		P_STAKIND3,				/* int16 */
+		P_STAKIND4,				/* int16 */
+		P_STAKIND5,				/* int16 */
+		P_STANUMBERS1,			/* float4[], null */
+		P_STANUMBERS2,			/* float4[], null */
+		P_STANUMBERS3,			/* float4[], null */
+		P_STANUMBERS4,			/* float4[], null */
+		P_STANUMBERS5,			/* float4[], null */
+		P_STAVALUES1,			/* text, null */
+		P_STAVALUES2,			/* text, null */
+		P_STAVALUES3,			/* text, null */
+		P_STAVALUES4,			/* text, null */
+		P_STAVALUES5,			/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *required_param_names[] = {
+		"relation",
+		"attname",
+		"stainherit",
+		"stanullfrac",
+		"stawidth",
+		"stadistinct",
+		"stakind1",
+		"stakind2",
+		"stakind3",
+		"stakind4",
+		"stakind5",
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+	HeapTuple	tuple;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	float4		stanullfrac;
+	int			stawidth;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+
+	/*
+	 * This function is pseudo-strct in that a NULL for the relation oid or
+	 * the attribute name results is a NULL return value.
+	 */
+	if (PG_ARGISNULL(P_RELATION) || PG_ARGISNULL(P_ATTNAME))
+		PG_RETURN_NULL();
+
+	for (int i = P_STAINHERIT; i <= P_STAKIND5; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", required_param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+	tuple = SearchSysCache2(ATTNAME,
+							ObjectIdGetDatum(relid),
+							NameGetDatum(attname));
+
+	if (!HeapTupleIsValid(tuple))
+	{
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	attr = (Form_pg_attribute) GETSTRUCT(tuple);
+	if (attr->attisdropped)
+	{
+		ReleaseSysCache(tuple);
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	stanullfrac = PG_GETARG_FLOAT4(P_STANULLFRAC);
+	if ((stanullfrac < 0.0) || (stanullfrac > 1.0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stanullfrac %f is out of range 0.0 to 1.0", stanullfrac)));
+
+	stawidth = PG_GETARG_INT32(P_STAWIDTH);
+	if (stawidth < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stawidth %d must be >= 0", stawidth)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_STAINHERIT);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_STANULLFRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_STAWIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_STADISTINCT);
+
+	/* The remaining fields are all parallel arrays, so we iterate over them */
+	for (int k = 0; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		int16		kind = PG_GETARG_INT16(P_STAKIND1 + k);
+		Oid			opoid;
+		Oid			colloid;
+
+		switch (kind)
+		{
+			case 0:
+				opoid = InvalidOid;
+				colloid = InvalidOid;
+				break;
+			case STATISTIC_KIND_MCV:
+				opoid = eqopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_HISTOGRAM:
+			case STATISTIC_KIND_CORRELATION:
+			case STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM:
+			case STATISTIC_KIND_BOUNDS_HISTOGRAM:
+				opoid = ltopr;
+				colloid = typcoll;
+				break;
+			case STATISTIC_KIND_MCELEM:
+			case STATISTIC_KIND_DECHIST:
+				opoid = baseeqopr;
+				colloid = typcoll;
+				break;
+			default:
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("stakind%d = %d is out of the range 0 to %d", k + 1,
+								kind, STATISTIC_KIND_BOUNDS_HISTOGRAM)));
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] = PG_GETARG_DATUM(P_STAKIND1 + k);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(opoid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(colloid);
+
+		if (PG_ARGISNULL(P_STANUMBERS1 + k))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] = PG_GETARG_DATUM(P_STANUMBERS1 + k);
+
+		if (PG_ARGISNULL(P_STAVALUES1 + k))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+		{
+			char	   *s = TextDatumGetCString(PG_GETARG_DATUM(P_STAVALUES1 + k));
+			FmgrInfo	finfo;
+
+			fmgr_info(F_ARRAY_IN, &finfo);
+
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				FunctionCall3(&finfo, CStringGetDatum(s), ObjectIdGetDatum(basetypid),
+							  Int32GetDatum(typmod));
+
+			pfree(s);
+		}
+	}
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_STAINHERIT));
+
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic] = {true};
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(tuple);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..56679c2615
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,211 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+        -1 |        0 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000, 999);
+ pg_set_relation_stats 
+-----------------------
+ t
+(1 row)
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+       3.6 |    15000 |           999
+(1 row)
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         4
+ test_clone   |         4
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..01087c9aee
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,198 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b float,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::float4, 15000, 999);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+-- copy stats from test to test_clone and is_odd to is_odd_clone
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+           || 'relation => %L::regclass, attname => %L::name, '
+           || 'stainherit => %L::boolean, stanullfrac => %s::real, '
+           || 'stawidth => %s::integer, stadistinct => %s::real, '
+           || 'stakind1 => %s::smallint, stakind2 => %s::smallint, '
+           || 'stakind3 => %s::smallint, stakind4 => %s::smallint, '
+           || 'stakind5 => %s::smallint, '
+           || 'stanumbers1 => %L::real[], stanumbers2 => %L::real[], '
+           || 'stanumbers3 => %L::real[], stanumbers4 => %L::real[], '
+           || 'stanumbers5 => %L::real[], '
+           || 'stavalues1 => %L::text, stavalues2 => %L::text, '
+           || 'stavalues3 => %L::text, stavalues4 => %L::text, '
+           || 'stavalues5 => %L::text)',
+        'stats_export_import.' || c.relname || '_clone', a.attname,
+        s.stainherit, s.stanullfrac,
+        s.stawidth, s.stadistinct,
+        s.stakind1, s.stakind2, s.stakind3,
+        s.stakind4, s.stakind5,
+        s.stanumbers1, s.stanumbers2,
+        s.stanumbers3, s.stanumbers4,
+        s.stanumbers5,
+        s.stavalues1::text, s.stavalues2::text, s.stavalues3::text,
+        s.stavalues4::text, s.stavalues5::text)
+FROM pg_class AS c
+JOIN pg_attribute a ON a.attrelid = c.oid
+JOIN pg_statistic s ON s.starelid = a.attrelid AND s.staattnum = a.attnum
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 72c5175e3b..7f97b45b22 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28756,6 +28756,101 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>reltuples</parameter> <type>float4</type>,
+         <parameter>relpages</parameter> <type>integer</type> )
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>attname</parameter> <type>name</type>,
+         <parameter>stainherit</parameter> <type>boolean</type>,
+         <parameter>stanullfrac</parameter> <type>real</type>,
+         <parameter>stawidth</parameter> <type>integer</type>,
+         <parameter>stadistinct</parameter> <type>real</type>,
+         <parameter>stakind1</parameter> <type>smallint</type>,
+         <parameter>stakind2</parameter> <type>smallint</type>,
+         <parameter>stakind3</parameter> <type>smallint</type>,
+         <parameter>stakind4</parameter> <type>smallint</type>,
+         <parameter>stakind5</parameter> <type>smallint</type>,
+         <parameter>stanumbers1</parameter> <type>real[]</type>,
+         <parameter>stanumbers2</parameter> <type>real[]</type>,
+         <parameter>stanumbers3</parameter> <type>real[]</type>,
+         <parameter>stanumbers4</parameter> <type>real[]</type>,
+         <parameter>stanumbers5</parameter> <type>real[]</type>,
+         <parameter>stavalues1</parameter> <type>text</type>,
+         <parameter>stavalues2</parameter> <type>text</type>,
+         <parameter>stavalues3</parameter> <type>text</type>,
+         <parameter>stavalues4</parameter> <type>text</type>,
+         <parameter>stavalues5</parameter> <type>text</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter> and <parameter>attname</parameter>.
+        The values for fields <structfield>staopN</structfield> and
+        <structfield>stacollN</structfield> are derived from the
+        <structname>pg_attribute</structname> row and the corresponding
+        <parameter>stakindN</parameter> value.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From 7ff026f3bb1a7ffb663a7221a1a9a69df33a3e7a Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 14 Mar 2024 04:42:41 -0400
Subject: [PATCH v9 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/include/fe_utils/stats_export.h  |  38 +++++
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 239 +++++++++++++++++++++++++++
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            |  60 +++++++
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 10 files changed, 355 insertions(+)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..eb2141d639
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,38 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+extern char *exportRelationStatsStmt(PGconn *conn, const char *srcrel,
+									 const char *destrel);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..cd2b38172c
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,239 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.reltuples, c.relpages, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace ";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.stainherit, "
+	"s.stanullfrac, s.stawidth, s.stadistinct, s.stakind1, s.stakind2, "
+	"s.stakind3, s.stakind4, s.stakind5, s.stanumbers1, s.stanumbers2, "
+	"s.stanumbers3, s.stanumbers4, s.stanumbers5, "
+	"s.stavalues1::text AS stavalues1, s.stavalues2::text AS stavalues2, "
+	"s.stavalues3::text AS stavalues3, s.stavalues4::text AS stavalues4, "
+	"s.stavalues5::text AS stavalues5 "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_statistic s ON s.starelid = a.attrelid AND s.staattnum = a.attnum ";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %s::float4, %s::integer, %s::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.reltuples, r.relpages, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT a.attnum, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"stainherit => %L::boolean, stanullfrac => %s::real, "
+			"stawidth => %s::integer, stadistinct => %s::real, "
+			"stakind1 => %s::smallint, stakind2 => %s::smallint, "
+			"stakind3 => %s::smallint, stakind4 => %s::smallint, "
+			"stakind5 => %s::smallint, "
+			"stanumbers1 => %L::real[], stanumbers2 => %L::real[], "
+			"stanumbers3 => %L::real[], stanumbers4 => %L::real[], "
+			"stanumbers5 => %L::real[], "
+			"stavalues1 => %L::text, stavalues2 => %L::text, "
+			"stavalues3 => %L::text, stavalues4 => %L::text, "
+			"stavalues5 => %L::text)', "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.stainherit, a.stanullfrac, a.stawidth, "
+			"a.stadistinct, a.stakind1, a.stakind2, a.stakind3, a.stakind4, "
+			"a.stakind5, a.stanumbers1, a.stanumbers2, a.stanumbers3, "
+			"a.stanumbers4, a.stanumbers5, a.stavalues1, a.stavalues2, "
+			"a.stavalues3, a.stavalues4, a.stavalues5) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
+
+/*
+ * Return the SQL command that will import all relation stats and attribute
+ * stats for a given relation.
+ *
+ * The return string is malloc()ed and must be freed by the caller.
+ *
+ * If the database is a version before 9.2, the function will return NULL
+ * with no corresponding error message. This can be verified beforehand via
+ * exportStatisticsSupported().
+ *
+ * Any other errors will result in the function returning NULL and the error
+ * message can be found via PQerrorMessage(conn).
+ *
+ */
+char *
+exportRelationStatsStmt(PGconn *conn, const char *srcrel, const char *destrel)
+{
+	const char *stmtname = "relstats";
+	const char *values[] = { srcrel, destrel };
+
+	static bool prepared = false;
+
+	PGresult   *res;
+	char	   *out = NULL;
+
+	/*
+	 * Most use-cases for this function involve invoking this function once for
+	 * each of a large set of relations. As such, using a prepapred statement 
+	 * make sense.
+	 */
+	if (!prepared)
+	{
+		char *sql = exportRelationStatsSQL(PQserverVersion(conn));
+
+		if (sql == NULL)
+			return NULL;
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+		{
+			PQclear(res);
+			return NULL;
+		}
+
+		free(sql);
+		prepared = true;
+	}
+
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+	/* Result set must be 1x1 */
+	if ((PQresultStatus(res) == PGRES_TUPLES_OK) && (PQntuples(res) == 1))
+		out = strdup(PQgetvalue(res, 0, 0));
+
+	PQclear(res);
+	return out;
+}
diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 171e591696..5a23034c7a 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -425,6 +426,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1130,6 +1132,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -6981,6 +6984,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7478,6 +7482,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10224,6 +10229,53 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj, char *reltypename)
+{
+	PGconn     *conn;
+	const char *qualname;
+	char	   *stmt;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	qualname = fmtQualifiedId(dobj->namespace->dobj.name,
+							  dobj->name);
+
+	stmt = exportRelationStatsStmt(conn, qualname, NULL);
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, stmt);
+	free(stmt);
+	appendPQExpBufferStr(query, ";\n");
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &(dobj->dumpId),
+							  .nDeps = 1));
+
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16657,6 +16709,10 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	if (tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16979,6 +17035,10 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 					is_constraint ? indxinfo->indexconstraint :
 					indxinfo->dobj.dumpId);
 
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX");
+
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
 	free(qindxname);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 491311fe79..37b6ba8a49 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From ba411ce31c25193cf05bc4206dcb8f2bf32af0c7 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Mon, 11 Mar 2024 14:18:39 -0400
Subject: [PATCH v10 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics would have to
make sense in the context of the new relation.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed.

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  15 +
 src/include/statistics/statistics.h           |   2 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 521 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 211 +++++++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 188 +++++++
 doc/src/sgml/func.sgml                        |  83 +++
 9 files changed, 1024 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 700f7daf7b..3070d72d7a 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12170,4 +12170,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid float4 int4 int4',
+  proargnames => '{relation,reltuples,relpages,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..19a4a740df
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,521 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+canModifyRelation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			 pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELTUPLES,			/* float4 */
+		P_RELPAGES,				/* int */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* The function is strict, but just to be safe */
+	Assert(!PG_ARGISNULL(P_RELATION) && !PG_ARGISNULL(P_RELTUPLES) &&
+		   !PG_ARGISNULL(P_RELPAGES) && !PG_ARGISNULL(P_RELALLVISIBLE));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	/*
+	 * TODO: choose an error code appropriate for this situation.
+	 * Canidates are:
+	 * ERRCODE_INVALID_CATALOG_NAME
+	 * ERRCODE_UNDEFINED_TABLE
+	 * ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE
+	 * ERRCODE_OBJECT_IN_USE
+	 * ERRCODE_SYSTEM_ERROR
+	 * ERRCODE_INTERNAL_ERROR
+	 */
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						 RelationGetRelationName(rel))));
+
+
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Convenience wrapper to confirm that the user can modify the relation.
+ * Use this when there is no need to modify the pg_class entry itself.
+ */
+static void
+checkCanModifyRelation(Relation rel)
+{
+	Oid				relid;
+	HeapTuple		tup;
+	Form_pg_class	pgcform;
+
+	relid = RelationGetRelid(rel);
+	tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(tup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(tup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						 RelationGetRelationName(rel))));
+
+	ReleaseSysCache(tup);
+}
+
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalue(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char   *s = TextDatumGetCString(d);
+	Datum out = FunctionCall3(finfo, CStringGetDatum(s),
+							  ObjectIdGetDatum(typid),
+							  Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * This function will return NULL if either the relation or the attname are
+ * NULL.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will return false. If there is a matching attribute but the
+ * attribute is dropped, then function will return false.
+ *
+ * The function does not specify values for staopN or stacollN parameters
+ * because those values are determined by the corresponding stakindN value and
+ * the attribute's underlying datatype.
+ *
+ * The stavaluesN parameters are text values, and must be a valid input string
+ * for an array of the basetype of the attribute. Any error generated by the
+ * array_in() function will in turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,		/* oid */
+		P_ATTNAME,			/* name */
+		P_INHERITED,		/* bool */
+		P_NULL_FRAC,		/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,		/* float4 */
+		P_MC_VALS,			/* text, null */
+		P_MC_FREQS,			/* float4[], null */
+		P_HIST_BOUNDS,		/* text, null */
+		P_CORRELATION,		/* float4, null */
+		P_MC_ELEMS,			/* text, null */
+		P_MC_ELEM_FREQS,	/* float4[], null */
+		P_ELEM_COUNT_HIST,	/* float[], null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *required_param_names[] = {
+		"relation",
+		"attname",
+		"stainherit",
+		"stanullfrac",
+		"stawidth",
+		"stadistinct"
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+	HeapTuple	atup;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	float4		stanullfrac;
+	int			stawidth;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+	FmgrInfo	finfo;
+
+	int k = 0;
+
+	/*
+	 * This function is pseudo-strct in that a NULL for the relation oid or
+	 * the attribute name results is a NULL return value.
+	 */
+	if (PG_ARGISNULL(P_RELATION) || PG_ARGISNULL(P_ATTNAME))
+		PG_RETURN_NULL();
+
+	for (int i = P_INHERITED; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", required_param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	attname = PG_GETARG_NAME(P_ATTNAME);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+	checkCanModifyRelation(rel);
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	checkCanModifyRelation(sd);
+
+	atup = SearchSysCache2(ATTNAME,
+						   ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	if (!HeapTupleIsValid(atup))
+	{
+		/* Attribute not found nowhere to import the stats to */
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+	{
+		ReleaseSysCache(atup);
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	stanullfrac = PG_GETARG_FLOAT4(P_NULL_FRAC);
+	if ((stanullfrac < 0.0) || (stanullfrac > 1.0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stanullfrac %f is out of range 0.0 to 1.0", stanullfrac)));
+
+	stawidth = PG_GETARG_INT32(P_AVG_WIDTH);
+	if (stawidth < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stawidth %d must be >= 0", stawidth)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS || MC_FREQS => STATISTIC_KIND_MCV */
+	if ((!PG_ARGISNULL(P_MC_VALS)) || (!PG_ARGISNULL(P_MC_FREQS)))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(eqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		if (PG_ARGISNULL(P_MC_FREQS))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				PG_GETARG_DATUM(P_MC_FREQS);
+
+		if (PG_ARGISNULL(P_MC_VALS))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_VALS), basetypid, typmod);
+
+		k++;
+	}
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_HIST_BOUNDS), basetypid, typmod);
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		Datum		elems[] = { PG_GETARG_DATUM(P_CORRELATION) };
+        ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS || MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if ((!PG_ARGISNULL(P_MC_ELEMS)) || (!PG_ARGISNULL(P_MC_ELEM_FREQS)))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM); 
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		if (PG_ARGISNULL(P_MC_ELEM_FREQS))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+
+		if (PG_ARGISNULL(P_MC_ELEMS))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+							  basetypid, typmod);
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST); 
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for(; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_INHERITED));
+
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic] = {true};
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(atup);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..e7af39bf51
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,211 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+        -1 |        0 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::real, 15000, 999);
+ pg_set_relation_stats 
+-----------------------
+ t
+(1 row)
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ reltuples | relpages | relallvisible 
+-----------+----------+---------------
+       3.6 |    15000 |           999
+(1 row)
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         4
+ test_clone   |         4
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..fabfc9b666
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,188 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    tags text[]
+);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 3.6::real, 15000, 999);
+
+SELECT reltuples, relpages, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type, array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %s::real, '
+            || 'avg_width => %s::integer, n_distinct => %s::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %s::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[]) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac, s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 3c52d90d3a..fdb05a0498 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28835,6 +28835,89 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relpages</parameter> <type>integer</type> )
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>attname</parameter> <type>name</type>,
+         <parameter>inherited</parameter> <type>boolean</type>,
+         <parameter>null_frac</parameter> <type>real</type>,
+         <parameter>avg_width</parameter> <type>integer</type>,
+         <parameter>n_distinct</parameter> <type>real</type>,
+         <parameter>most_common_vals</parameter> <type>text</type>,
+         <parameter>most_common_freqs</parameter> <type>real[]</type>,
+         <parameter>histogram_bounds</parameter> <type>text</type>,
+         <parameter>correlation</parameter> <type>real</type>,
+         <parameter>most_common_elems</parameter> <type>text</type>,
+         <parameter>most_common_elem_freqs</parameter> <type>real[]</type>,
+         <parameter>elem_count_histogram</parameter> <type>real[]</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter> and <parameter>attname</parameter>.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From ab5556cb26af437ea7b3837c94988c2587db95ca Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v10 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/include/fe_utils/stats_export.h  |  36 ++++++
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 178 +++++++++++++++++++++++++++
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            |  91 ++++++++++++++
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 10 files changed, 323 insertions(+)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..f0dc7041f7
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..106907df09
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,178 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.reltuples, c.relpages, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elems_freq, s.elem_count_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %s::real, %s::integer, %s::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.reltuples, r.relpages, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT 1, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"inherited => %L::boolean, null_frac => %s::real, "
+			"avg_width => %s::integer, n_distinct => %s::real, "
+			"most_common_vals => %L::text, "
+			"most_common_freqs => %L::real[], "
+			"most_common_bounds => %L::text, "
+			"correlation => %s::real, "
+			"most_common_elems => %L::text, "
+			"most_common_elems_freq => %L::real[], "
+			"elem_count_histogram => %L::real[]) "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.inherited, a.null_frac, a.avg_width, "
+			"a.n_distinct, a.most_common_vals, a.most_common_freqs, "
+			"a.most_common_bounds, a.correlation, "
+			"a.most_common_elems, a.most_common_elems_freq, "
+			"a.elem_count_histogram) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index a5149ca823..8c29e2ddf6 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -425,6 +426,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1130,6 +1132,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -6981,6 +6984,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7478,6 +7482,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10227,6 +10232,82 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename)
+{
+	const char *stmtname = "relstats";
+	static bool prepared = false;
+	const char *values[2];
+	PGconn     *conn;
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	if (!prepared)
+	{
+		int		ver = PQserverVersion(conn);
+		char   *sql = exportRelationStatsSQL(ver);
+
+		if (sql == NULL)
+			pg_fatal("could not prepare stats export query for server version %d",
+					 ver);
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+			pg_fatal("prepared statement failed: %s",
+					 PQerrorMessage(conn));
+
+		free(sql);
+		prepared = true;
+	}
+
+	values[0] = fmtQualifiedId(dobj->namespace->dobj.name, dobj->name);
+	values[1] = NULL;
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+
+	/* Result set must be 1x1 */
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
+
+	if (PQntuples(res) != 1)
+		pg_fatal("statistics extraction expected one row, but got %d rows", 
+				 PQntuples(res));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, strdup(PQgetvalue(res, 0, 0)));
+	appendPQExpBufferStr(query, ";\n");
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &(dobj->dumpId),
+							  .nDeps = 1));
+
+	PQclear(res);
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16660,6 +16741,12 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind == RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16982,6 +17069,10 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 					is_constraint ? indxinfo->indexconstraint :
 					indxinfo->dobj.dumpId);
 
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX");
+
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
 	free(qindxname);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 491311fe79..37b6ba8a49 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From 5c63ed5748eb3817d193b64329b57dc590e0196e Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Mon, 11 Mar 2024 14:18:39 -0400
Subject: [PATCH v11 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics would have to
make sense in the context of the new relation.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed.

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  15 +
 src/include/statistics/statistics.h           |   2 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 603 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 283 ++++++++
 src/test/regress/parallel_schedule            |   2 +-
 src/test/regress/sql/stats_export_import.sql  | 246 +++++++
 doc/src/sgml/func.sgml                        |  91 +++
 9 files changed, 1244 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 177d81a891..f31412d4a6 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12177,4 +12177,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 't',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'bool',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..f27bfd60a3
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,603 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+canModifyRelation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			 pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* The function is strict, but just to be safe */
+	Assert(!PG_ARGISNULL(P_RELATION) && !PG_ARGISNULL(P_RELTUPLES) &&
+		   !PG_ARGISNULL(P_RELPAGES) && !PG_ARGISNULL(P_RELALLVISIBLE));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	/*
+	 * TODO: choose an error code appropriate for this situation.
+	 * Canidates are:
+	 * ERRCODE_INVALID_CATALOG_NAME
+	 * ERRCODE_UNDEFINED_TABLE
+	 * ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE
+	 * ERRCODE_OBJECT_IN_USE
+	 * ERRCODE_SYSTEM_ERROR
+	 * ERRCODE_INTERNAL_ERROR
+	 */
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						 RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Convenience wrapper to confirm that the user can modify the relation.
+ * Use this when there is no need to modify the pg_class entry itself.
+ */
+static void
+checkCanModifyRelation(Relation rel)
+{
+	Oid				relid;
+	HeapTuple		tup;
+	Form_pg_class	pgcform;
+
+	relid = RelationGetRelid(rel);
+	tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(tup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(tup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						 RelationGetRelationName(rel))));
+
+	ReleaseSysCache(tup);
+}
+
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalue(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char   *s = TextDatumGetCString(d);
+	Datum out = FunctionCall3(finfo, CStringGetDatum(s),
+							  ObjectIdGetDatum(typid),
+							  Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * This function will return NULL if either the relation or the attname are
+ * NULL.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will return false. If there is a matching attribute but the
+ * attribute is dropped, then function will return false.
+ *
+ * The function does not specify values for staopN or stacollN parameters
+ * because those values are determined by the corresponding stakindN value and
+ * the attribute's underlying datatype.
+ *
+ * The stavaluesN parameters are text values, and must be a valid input string
+ * for an array of the basetype of the attribute. Any error generated by the
+ * array_in() function will in turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *required_param_names[] = {
+		"relation",
+		"attname",
+		"stainherit",
+		"stanullfrac",
+		"stawidth",
+		"stadistinct"
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+	HeapTuple	atup;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	float4		stanullfrac;
+	int			stawidth;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+	FmgrInfo	finfo;
+
+	int k = 0;
+
+	/*
+	 * This function is pseudo-strct in that a NULL for the relation oid or
+	 * the attribute name results is a NULL return value.
+	 */
+	if (PG_ARGISNULL(P_RELATION) || PG_ARGISNULL(P_ATTNAME))
+		PG_RETURN_NULL();
+
+	for (int i = P_INHERITED; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", required_param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	attname = PG_GETARG_NAME(P_ATTNAME);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+	checkCanModifyRelation(rel);
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	checkCanModifyRelation(sd);
+
+	atup = SearchSysCache2(ATTNAME,
+						   ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	if (!HeapTupleIsValid(atup))
+	{
+		/* Attribute not found nowhere to import the stats to */
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+	{
+		ReleaseSysCache(atup);
+		relation_close(rel, NoLock);
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	/*
+	 * if it's a range type, swap the subtype for the base type
+	 */
+	if (type_is_range(typid))
+		basetypid = get_range_subtype(typid);
+	else
+		basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	stanullfrac = PG_GETARG_FLOAT4(P_NULL_FRAC);
+	if ((stanullfrac < 0.0) || (stanullfrac > 1.0))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stanullfrac %f is out of range 0.0 to 1.0", stanullfrac)));
+
+	stawidth = PG_GETARG_INT32(P_AVG_WIDTH);
+	if (stawidth < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("stawidth %d must be >= 0", stawidth)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS || MC_FREQS => STATISTIC_KIND_MCV */
+	if ((!PG_ARGISNULL(P_MC_VALS)) || (!PG_ARGISNULL(P_MC_FREQS)))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(eqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		if (PG_ARGISNULL(P_MC_FREQS))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				PG_GETARG_DATUM(P_MC_FREQS);
+
+		if (PG_ARGISNULL(P_MC_VALS))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_VALS), basetypid, typmod);
+
+		k++;
+	}
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_HIST_BOUNDS), basetypid, typmod);
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		Datum		elems[] = { PG_GETARG_DATUM(P_CORRELATION) };
+        ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS || MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if ((!PG_ARGISNULL(P_MC_ELEMS)) || (!PG_ARGISNULL(P_MC_ELEM_FREQS)))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM); 
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		if (PG_ARGISNULL(P_MC_ELEM_FREQS))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+				PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+
+		if (PG_ARGISNULL(P_MC_ELEMS))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+							  basetypid, typmod);
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST); 
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * After this point, it is theoretically possible to overflow
+	 * STATISTIC_NUM_SLOTS so we should check that before adding any
+	 * more stat entries.
+	 */
+
+	/*
+	 * ELEM_COUNT_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 * even though it is numerically greater, and all other stakinds
+	 * appear in numerical order. We duplicate this quirk to make
+	 * before/after tests of pg_statistic records easier.
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+		if (k >= (STATISTIC_NUM_SLOTS - 1))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("imported statistics must have a maximum of %d slots",
+							STATISTIC_NUM_SLOTS)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST), typid, typmod);
+
+		k++;
+	}
+
+	/* P_RANGE_LENGTH_HIST || P_RANGE_EMPTY_FRAC => STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM */
+	if ((!PG_ARGISNULL(P_RANGE_LENGTH_HIST)) ||
+		(!PG_ARGISNULL(P_RANGE_EMPTY_FRAC)))
+	{
+		if (k >= (STATISTIC_NUM_SLOTS - 1))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("imported statistics must have a maximum of %d slots",
+							STATISTIC_NUM_SLOTS)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+
+		if (PG_ARGISNULL(P_RANGE_EMPTY_FRAC))
+			nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		else
+		{
+			Datum		elems[] = { PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC) };
+			ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+			values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		}
+
+		if (PG_ARGISNULL(P_RANGE_LENGTH_HIST))
+			nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+		else
+			values[Anum_pg_statistic_stavalues1 - 1 + k] =
+				cast_stavalue(&finfo, PG_GETARG_DATUM(P_RANGE_LENGTH_HIST), FLOAT8OID, typmod);
+
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for(; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_INHERITED));
+
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic] = {true};
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(atup);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..2e4c7fada6
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,283 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ t
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 0.9::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[],
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[],
+    range_length_histogram => NULL::text,
+    range_empty_frac => NULL::real,
+    range_bounds_histogram => NULL::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 | {1,2,3}          | {0.1,0.2,0.3}     | {1,2,3,4}        |         0.9 | {1,3}             | {0.3,0.2}              | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => NULL::real[],
+    histogram_bounds => NULL::text,
+    correlation => NULL::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => NULL::real[],
+    elem_count_histogram => NULL::real[],
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_empty_frac => 0.5::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT range_empty_frac, range_bounds_histogram
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND attname = 'arange';
+ range_empty_frac |        range_bounds_histogram        
+------------------+--------------------------------------
+              0.5 | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ t
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 1d8a414eea..0c89ffc02d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -103,7 +103,7 @@ test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combo
 # ----------
 # Another group of parallel tests (JSON related)
 # ----------
-test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson
+test: json jsonb json_encoding jsonpath jsonpath_encoding jsonb_jsonpath sqljson stats_export_import
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..4788929bdd
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,246 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 0.9::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[],
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[],
+    range_length_histogram => NULL::text,
+    range_empty_frac => NULL::real,
+    range_bounds_histogram => NULL::text
+    );
+
+
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND attname = 'id';
+
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => NULL::real[],
+    histogram_bounds => NULL::text,
+    correlation => NULL::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => NULL::real[],
+    elem_count_histogram => NULL::real[],
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_empty_frac => 0.5::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT range_empty_frac, range_bounds_histogram
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND attname = 'arange';
+
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 5b225ccf4f..75aa3e3d1c 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -28865,6 +28865,97 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type> )
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>attname</parameter> <type>name</type>,
+         <parameter>inherited</parameter> <type>boolean</type>,
+         <parameter>null_frac</parameter> <type>real</type>,
+         <parameter>avg_width</parameter> <type>integer</type>,
+         <parameter>n_distinct</parameter> <type>real</type>,
+         <parameter>most_common_vals</parameter> <type>text</type>,
+         <parameter>most_common_freqs</parameter> <type>real[]</type>,
+         <parameter>histogram_bounds</parameter> <type>text</type>,
+         <parameter>correlation</parameter> <type>real</type>,
+         <parameter>most_common_elems</parameter> <type>text</type>,
+         <parameter>most_common_elem_freqs</parameter> <type>real[]</type>,
+         <parameter>elem_count_histogram</parameter> <type>real[]</type>,
+         <parameter>range_length_histogram</parameter> <type>text</type>,
+         <parameter>range_empty_frac</parameter> <type>real</type>,
+         <parameter>range_bounds_histogram</parameter> <type>text</type>)
+        <returnvalue>boolean</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>.  Aside from
+        <parameter>relation</parameter>, the parameters in this are all
+        derived from <structname>pg_stats</structname>, and the values
+        given are most often extracted from there.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next auto-analyze. This function is used by
+        <command>pg_dump</command>, <command>pg_restore</command>, and 
+        <command>pg_upgrade</command> to convey the statistics from the old
+        system version into the new one.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From db1e0b5bbb2a8f640f45d8a7271831535c3d1cea Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v11 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/include/fe_utils/stats_export.h  |  36 +++++
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 201 +++++++++++++++++++++++++++
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 100 ++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 10 files changed, 353 insertions(+), 2 deletions(-)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..f0dc7041f7
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..fd09e6ea8a
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,201 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.relpages, c.reltuples, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace";
+
+const char *export_attribute_stats_query_v17 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"s.range_length_histogram::text AS range_length_histogram, "
+	"s.range_empty_frac, "
+	"s.range_bounds_histogram::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"NULL::text AS range_length_histogram, NULL::real AS range_empty_frac, "
+	"NULL::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= 170000)
+		return export_attribute_stats_query_v17;
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %L::integer, %L::real, %L::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.relpages, r.reltuples, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT 1, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"inherited => %L::boolean, null_frac => %L::real, "
+			"avg_width => %L::integer, n_distinct => %L::real, "
+			"most_common_vals => %L::text, "
+			"most_common_freqs => %L::real[], "
+			"histogram_bounds => %L::text, "
+			"correlation => %L::real, "
+			"most_common_elems => %L::text, "
+			"most_common_elem_freqs => %L::real[], "
+			"elem_count_histogram => %L::real[], "
+			"range_length_histogram => %L::text, "
+			"range_empty_frac => %L::real, "
+			"range_bounds_histogram => %L::text)', "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.inherited, a.null_frac, a.avg_width, "
+			"a.n_distinct, a.most_common_vals, a.most_common_freqs, "
+			"a.histogram_bounds, a.correlation, "
+			"a.most_common_elems, a.most_common_elem_freqs, "
+			"a.elem_count_histogram, a.range_length_histogram, "
+			"a.range_empty_frac, a.range_bounds_histogram ) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index a5149ca823..5db230e020 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -425,6 +426,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1130,6 +1132,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -6981,6 +6984,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7478,6 +7482,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10227,6 +10232,82 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	const char *stmtname = "relstats";
+	static bool prepared = false;
+	const char *values[2];
+	PGconn     *conn;
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	if (!prepared)
+	{
+		int		ver = PQserverVersion(conn);
+		char   *sql = exportRelationStatsSQL(ver);
+
+		if (sql == NULL)
+			pg_fatal("could not prepare stats export query for server version %d",
+					 ver);
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+			pg_fatal("prepared statement failed: %s",
+					 PQerrorMessage(conn));
+
+		free(sql);
+		prepared = true;
+	}
+
+	values[0] = fmtQualifiedId(dobj->namespace->dobj.name, dobj->name);
+	values[1] = NULL;
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+
+	/* Result set must be 1x1 */
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
+
+	if (PQntuples(res) != 1)
+		pg_fatal("statistics extraction expected one row, but got %d rows", 
+				 PQntuples(res));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, strdup(PQgetvalue(res, 0, 0)));
+	appendPQExpBufferStr(query, ";\n");
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	PQclear(res);
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16660,6 +16741,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind == RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16861,6 +16949,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16973,14 +17062,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+							 indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 491311fe79..37b6ba8a49 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From e2f1bce46a265d7c76ce1d48c1f46cae41c20286 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 21 Mar 2024 18:04:54 -0400
Subject: [PATCH v12 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics have to make
sense in the context of the new relation.

The statistics provided will be checked for suitability and consistency,
and will raise an error if found.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed. All stakind-based
statistics parameters has a default value of NULL.

In addition, the values provided are checked for consistency where
possible (values in acceptable ranges, array values in sub-ranges
defined within the array itself, array values in order, etc).

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |  15 +
 src/include/statistics/statistics.h           |   2 +
 src/backend/catalog/system_functions.sql      |  18 +
 src/backend/statistics/Makefile               |   3 +-
 src/backend/statistics/meson.build            |   1 +
 src/backend/statistics/statistics.c           | 934 ++++++++++++++++++
 .../regress/expected/stats_export_import.out  | 827 ++++++++++++++++
 src/test/regress/parallel_schedule            |   3 +-
 src/test/regress/sql/stats_export_import.sql  | 730 ++++++++++++++
 doc/src/sgml/func.sgml                        | 110 +++
 10 files changed, 2641 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index ea45b300b8..180be2c768 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12180,4 +12180,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index fe2bb50f46..22be7e6653 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -636,6 +636,24 @@ LANGUAGE INTERNAL
 CALLED ON NULL INPUT VOLATILE PARALLEL SAFE
 AS 'pg_stat_reset_slru';
 
+CREATE OR REPLACE FUNCTION
+  pg_set_attribute_stats(relation oid, attname name, inherited bool,
+                         null_frac real, avg_width integer, n_distinct real,
+                         most_common_vals text DEFAULT NULL,
+                         most_common_freqs real[] DEFAULT NULL,
+                         histogram_bounds text DEFAULT NULL,
+                         correlation real DEFAULT NULL,
+                         most_common_elems text DEFAULT NULL,
+                         most_common_elem_freqs real[] DEFAULT NULL,
+                         elem_count_histogram real[] DEFAULT NULL,
+                         range_length_histogram text DEFAULT NULL,
+                         range_empty_frac real DEFAULT NULL,
+                         range_bounds_histogram text DEFAULT NULL)
+RETURNS void
+LANGUAGE INTERNAL
+CALLED ON NULL INPUT VOLATILE
+AS 'pg_set_attribute_stats';
+
 --
 -- The default permissions for functions mean that anyone can execute them.
 -- A number of functions shouldn't be executable by just anyone, but rather
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..4149cab8d1
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,934 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_oper.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+canModifyRelation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	const char *param_names[] = {
+		"relation",
+		"relpages",
+		"reltuples",
+		"relallvisible"
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* Any NULL parameter is an error */
+	for (int i = P_RELATION; i < P_NUM_PARAMS; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	/*
+	 * TODO: choose an error code appropriate for this situation. Canidates
+	 * are: ERRCODE_INVALID_CATALOG_NAME ERRCODE_UNDEFINED_TABLE
+	 * ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE ERRCODE_OBJECT_IN_USE
+	 * ERRCODE_SYSTEM_ERROR ERRCODE_INTERNAL_ERROR
+	 */
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_VOID();
+}
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalue(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char	   *s = TextDatumGetCString(d);
+	Datum		out = FunctionCall3(finfo, CStringGetDatum(s),
+									ObjectIdGetDatum(typid),
+									Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+/*
+ * Convenience routine to handle a common pattern where two function
+ * parameters must either both be NULL or both NOT NULL.
+ */
+static bool
+has_arg_pair(FunctionCallInfo fcinfo, const char **pnames, int p1, int p2)
+{
+	/* if on param is NULL and the other NOT NULL, report an error */
+	if (PG_ARGISNULL(p1) != PG_ARGISNULL(p2))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be NULL when %s is NOT NULL",
+					 	pnames[(PG_ARGISNULL(p1)) ? p1 : p2],
+					 	pnames[(PG_ARGISNULL(p1)) ? p2 : p1])));
+
+	return (!PG_ARGISNULL(p1));
+}
+
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * The function takes input parameters that correspond to columns in the view
+ * pg_stats.
+ *
+ * Of those, the columns attname, inherited, null_frac, avg_width, and
+ * n_distinct all correspond to NOT NULL columns in pg_statistic. These
+ * parameters have no default value and passing NULL to them will result
+ * in an error.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will raise an error. Likewise for setting inherited statistics
+ * on a table that is not partitioned.
+ *
+ * The remaining parameters all belong to a specific stakind. Some stakinds
+ * have multiple parameters, and in those cases both parameters must be
+ * NOT NULL or both NULL, otherwise an error will be raised.
+ *
+ * Omitting a parameter or explicitly passing NULL means that that particular
+ * stakind is not associated with the attribute.
+ *
+ * Parameters that are NOT NULL will be inspected for consistency checks,
+ * any of which can raise an error.
+ *
+ * Parameters corresponding to ANYARRAY columns are instead passed in as text
+ * values, which is a valid input string for an array of the type or basetype
+ * of the attribute. Any error generated by the array_in() function will in
+ * turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *param_names[] = {
+		"relation",
+		"attname",
+		"inherited",
+		"null_frac",
+		"avg_width",
+		"n_distinct",
+		"most_common_vals",
+		"most_common_freqs",
+		"histogram_bounds",
+		"correlation",
+		"most_common_elems",
+		"most_common_elem_freqs",
+		"elem_count_histogram",
+		"range_length_histogram",
+		"range_empty_frac",
+		"range_bounds_histogram"
+	};
+
+	Oid			relid;
+	Name		attname;
+	bool		inherited;
+	Relation	rel;
+	HeapTuple	ctup;
+	HeapTuple	atup;
+	Form_pg_class pgcform;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	const float4 frac_min = 0.0;
+	const float4 frac_max = 1.0;
+	float4		null_frac;
+	const int	avg_width_min = 0;
+	int			avg_width;
+	const float4 n_distinct_min = -1.0;
+	float4		n_distinct;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+	FmgrInfo	finfo;
+
+	bool		has_mcv;
+	bool		has_mc_elems;
+	bool		has_rl_hist;
+	int			stakind_count;
+
+	int			k = 0;
+
+	/*
+	 * A null in a required parameter is an error.
+	 */
+	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	/*
+	 * Check all parameter pairs up front.
+	 */
+	has_mcv = has_arg_pair(fcinfo, param_names,
+						   P_MC_VALS, P_MC_FREQS);
+	has_mc_elems = has_arg_pair(fcinfo, param_names,
+								P_MC_ELEMS, P_MC_ELEM_FREQS);
+	has_rl_hist = has_arg_pair(fcinfo, param_names,
+							   P_RANGE_LENGTH_HIST, P_RANGE_EMPTY_FRAC);
+
+	/*
+	 * If a caller specifies more stakind-stats than we have slots to store
+	 * them, raise an error.
+	 */
+	stakind_count = (int)has_mcv + (int)has_mc_elems + (int)has_rl_hist +
+		(int)!PG_ARGISNULL(P_HIST_BOUNDS) +
+		(int)!PG_ARGISNULL(P_CORRELATION) +
+		(int)!PG_ARGISNULL(P_ELEM_COUNT_HIST) +
+		(int)!PG_ARGISNULL(P_RANGE_BOUNDS_HIST);
+
+	if (stakind_count > STATISTIC_NUM_SLOTS)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("imported statistics must have a maximum of %d slots "
+					 	"but %d given",
+						STATISTIC_NUM_SLOTS, stakind_count)));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	/* Test existence of Relation */
+	ctup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+	ReleaseSysCache(ctup);
+
+	/*
+	 * Test existence of attribute
+	 */
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	atup = SearchSysCache2(ATTNAME,
+						   ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	/* Attribute not found nowhere to import the stats to */
+	if (!HeapTupleIsValid(atup))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s has no attname %s",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s attname %s is dropped",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	/* Test inherited */
+	inherited = PG_GETARG_BOOL(P_INHERITED);
+	if (inherited &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s is not partitioned, cannot accept inherited stats",
+						RelationGetRelationName(rel))));
+
+	/*
+	 * Fetch datatype information, this is needed to derive the proper staopN
+	 * and stacollN values.
+	 *
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+	get_sort_group_operators(typid, false, false, false,
+							 &ltopr, &eqopr, NULL, NULL);
+
+	/*
+	 * if it's a range type, swap the subtype for the base type
+	 */
+	if (type_is_range(typid))
+		basetypid = get_range_subtype(typid);
+	else
+		basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+		get_sort_group_operators(basetypid, false, false, false,
+								 &baseltopr, &baseeqopr, NULL, NULL);
+
+	/*
+	 * Statistical parameters that must pass data validity tests
+	 */
+	null_frac = PG_GETARG_FLOAT4(P_NULL_FRAC);
+	if ((null_frac < frac_min) || (null_frac > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						param_names[P_NULL_FRAC], null_frac,
+						frac_min, frac_max)));
+
+	avg_width = PG_GETARG_INT32(P_AVG_WIDTH);
+	if (avg_width < avg_width_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %d must be >= %d",
+						param_names[P_AVG_WIDTH], avg_width, avg_width_min)));
+
+	n_distinct = PG_GETARG_FLOAT4(P_N_DISTINCT);
+	if (n_distinct < n_distinct_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f must be >= %.1f",
+						param_names[P_N_DISTINCT], n_distinct,
+						n_distinct_min)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS && MC_FREQS => STATISTIC_KIND_MCV */
+	if (has_mcv)
+	{
+		Datum		freqs = PG_GETARG_DATUM(P_MC_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_VALS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			freqsdims = freqsarr->ndims;
+		int			valsdims = valsarr->ndims;
+		int			nfreqs = freqsarr->dims[0];
+		int			nvals = valsarr->dims[0];
+
+		const float4 freqsummax = 1.1;
+		float4		freqsum = 0.0;
+		float4		prev = get_float4_infinity();
+
+		if (freqsdims != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be a multidimensional array",
+							param_names[P_MC_FREQS])));
+		if (valsdims != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be a multidimensional array",
+							param_names[P_MC_VALS])));
+
+		if (nfreqs != nvals)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s has %d elements, but %s has %d elements, "
+							"but they must be equal",
+							param_names[P_MC_FREQS], nfreqs,
+							param_names[P_MC_VALS], nvals)));
+
+		/*
+		 * check that freqs sum to <= 1.0 or some number slightly higer to
+		 * allow for compounded rounding errors.
+		 */
+
+		deconstruct_expanded_array(freqsarr);
+
+		/* if there's a nulls array, all values must be false */
+		if (freqsarr->dnulls != NULL)
+			for (int i = 0; i < nfreqs; i++)
+				if (freqsarr->dnulls[i])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array cannot contain NULL values",
+									param_names[P_MC_FREQS])));
+
+		for (int i = 0; i < nfreqs; i++)
+		{
+			float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+			if (f > prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in descending "
+								"order, but %f > %f",
+								param_names[P_MC_FREQS], f, prev)));
+
+			freqsum += f;
+			prev = f;
+		}
+
+		if (freqsum > freqsummax)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("The sum of elements in %s must not exceed "
+							"%.2f but is %f",
+							param_names[P_MC_FREQS],
+							freqsummax, freqsum)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(eqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = freqs;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = vals;
+
+		k++;
+	}
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		/*
+		 * This is a histogram, which means that the values must be in
+		 * monotonically non-decreasing order, the effort required to
+		 * verify that isn't practical.
+		 */
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_HIST_BOUNDS), basetypid, typmod);
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		Datum		elem = PG_GETARG_DATUM(P_CORRELATION);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		const float4 corr_min = -1.0;
+		const float4 corr_max = 1.0;
+		float4		corr = PG_GETARG_FLOAT4(P_CORRELATION);
+
+		if ((corr < corr_min) || (corr > corr_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %f is out of range %.1f to %.1f",
+							param_names[P_CORRELATION], corr, corr_min,
+							corr_max)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS && MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if (has_mc_elems)
+	{
+		Datum		freqs = PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			freqsdims = freqsarr->ndims;
+		int			valsdims = valsarr->ndims;
+		int			nfreqs = freqsarr->dims[0];
+		int			nvals = valsarr->dims[0];
+
+		/*
+		 * The mcelem freqs array has either 2 or 3 additional values: the min
+		 * frequency, the max frequency, the optional null frequency.
+		 */
+		int			nfreqsmin = nvals + 2;
+		int			nfreqsmax = nvals + 3;
+
+		float4		freqlowbound;
+		float4		freqhighbound;
+
+		if (freqsdims != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be a multidimensional array",
+							param_names[P_MC_ELEM_FREQS])));
+		if (valsdims != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be a multidimensional array",
+							param_names[P_MC_ELEMS])));
+
+		if (nfreqs > 0)
+		{
+			float4		prev = get_float4_infinity();
+
+			if ((nfreqs < nfreqsmin) || (nfreqs > nfreqsmax))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s has %d elements, but must have between "
+								"%d and %d because %s has %d elements",
+								param_names[P_MC_ELEM_FREQS], nfreqs,
+								nfreqsmin, nfreqsmax, param_names[P_MC_ELEMS],
+								nvals)));
+
+			deconstruct_expanded_array(freqsarr);
+
+			/* if there's a nulls array, all values must be false */
+			if (freqsarr->dnulls != NULL)
+				for (int i = 0; i < nfreqs; i++)
+					if (freqsarr->dnulls[i])
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("%s array cannot contain NULL values",
+										param_names[P_MC_ELEM_FREQS])));
+
+			/*
+			 * the freqlowbound and freqhighbound must themselves be valid
+			 * percentages
+			 */
+
+			/* first freq element past the length of the values is the min */
+			freqlowbound = DatumGetFloat4(freqsarr->dvalues[nvals]);
+			if ((freqlowbound < frac_min) || (freqlowbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of range %.1f to %.1f",
+								param_names[P_MC_ELEM_FREQS], "minimum",
+								freqlowbound, frac_min, frac_max)));
+
+			/* second freq element past the length of the values is the max */
+			freqhighbound = DatumGetFloat4(freqsarr->dvalues[nvals + 1]);
+			if ((freqhighbound < frac_min) || (freqhighbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of range %.1f to %.1f",
+								param_names[P_MC_ELEM_FREQS], "maximum", freqhighbound,
+								frac_min, frac_max)));
+
+			/* low bound must be < high bound */
+			if (freqlowbound > freqhighbound)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s frequency low bound %f cannot be greater "
+								"than high bound %f",
+								param_names[P_MC_ELEM_FREQS], freqlowbound,
+								freqhighbound)));
+
+			/*
+			 * third freq element past the length of the values is the null
+			 * frac
+			 */
+			if (nfreqs == nvals + 3)
+			{
+				float4		freqnullpct = DatumGetFloat4(freqsarr->dvalues[nvals + 2]);
+
+				if ((freqnullpct < frac_min) || (freqnullpct > frac_max))
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s %s frequency %f is out of range %.1f to %.1f",
+									param_names[P_MC_ELEM_FREQS], "null", freqnullpct,
+									frac_min, frac_max)));
+			}
+
+			/*
+			 * All the freqs that match up to a val must bet between low/high
+			 * bounds (which is never less strict than frac_min/frac_max) and
+			 * must be in monotonically non-increasing order.
+			 *
+			 * Also, these frequencies do not sum to a number <= 1.0 as is the
+			 * case with MC_FREQS.
+			 */
+			for (int i = 0; i < nvals; i++)
+			{
+				float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+				if ((f < freqlowbound) || (f > freqhighbound))
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s frequency %f is out of range %f to %f",
+									param_names[P_MC_ELEM_FREQS], f, freqlowbound,
+									freqhighbound)));
+				if (f > prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in descending "
+									"order, but %f > %f",
+									param_names[P_MC_ELEM_FREQS], f, prev)));
+
+				prev = f;
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+						  basetypid, typmod);
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * RANGE_BOUNDS_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM even though
+	 * it is numerically greater, and all other stakinds appear in numerical
+	 * order. We duplicate this quirk to make before/after tests of
+	 * pg_statistic records easier.
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST), typid, typmod);
+
+		k++;
+	}
+
+	/*
+	 * P_RANGE_LENGTH_HIST && P_RANGE_EMPTY_FRAC =>
+	 * STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM
+	 */
+	if (has_rl_hist)
+	{
+		Datum		elem = PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+		float8		prev = -get_float8_infinity();
+		float4		frac = DatumGetFloat4(elem);
+
+		Datum		stavalue;
+
+		ExpandedArrayHeader	   *arr;
+
+		int			dims;
+		int			nelems;
+
+		if ((frac < frac_min) || (frac > frac_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("range_empty_frac %f is out of range %.1f to %.1f",
+						 	frac, frac_min, frac_max)));
+
+		/*
+		 * RANGE_LENGTH_HIST is stored in an anyarray, but it is known to be
+		 * of type float8[]. It is also a histogram, so it must be in
+		 * monotonically nondecreasing order.
+		 */
+		stavalue = cast_stavalue(&finfo,
+								 PG_GETARG_DATUM(P_RANGE_LENGTH_HIST),
+								 FLOAT8OID, typmod);
+
+		arr = DatumGetExpandedArray(stavalue);
+
+		deconstruct_expanded_array(arr);
+		dims = arr->ndims;
+		nelems = arr->dims[0];
+
+		if (dims != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be a multidimensional array",
+							param_names[P_RANGE_LENGTH_HIST])));
+
+		for (int i = 0; i < nelems; i++)
+		{
+			float8		f = DatumGetFloat8(arr->dvalues[i]);
+
+			if (f < prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in ascending "
+								"order, but %f > %f",
+								param_names[P_RANGE_LENGTH_HIST], prev, f)));
+
+			prev = f;
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalue;
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for (; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_INHERITED));
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic];
+
+		for (int i = 0; i < Natts_pg_statistic; i++)
+			replaces[i] = true;
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(atup);
+	PG_RETURN_VOID();
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..a30a6fdd19
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,827 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ 
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+ERROR:  relpages cannot be NULL
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  could not open relation with OID 0
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  relation cannot be NULL
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  attname cannot be NULL
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  inherited cannot be NULL
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  Relation test is not partitioned, cannot accept inherited stats
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+ERROR:  n_distinct cannot be NULL
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 |                  |                   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac -0.100000 is out of range 0.0 to 1.0
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac 1.100000 is out of range 0.0 to 1.0
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width -1 must be >= 0
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+ERROR:  n_distinct -1.100000 must be >= -1.0
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_vals cannot be NULL when most_common_freqs is NOT NULL
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+ERROR:  most_common_freqs cannot be NULL when most_common_vals is NOT NULL
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+ERROR:  most_common_freqs has 2 elements, but most_common_vals has 3 elements, but they must be equal
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+ERROR:  The sum of elements in most_common_freqs must not exceed 1.10 but is 1.400000
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 | {2,1,3}          | {0.3,0.25,0.05}   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   | {1,2,3,4}        |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+ERROR:  correlation -1.100000 is out of range -1.0 to 1.0
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+ERROR:  correlation 1.100000 is out of range -1.0 to 1.0
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+ERROR:  most_common_elem_freqs cannot be NULL when most_common_elems is NOT NULL
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_elems cannot be NULL when most_common_elem_freqs is NOT NULL
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+ERROR:  most_common_elem_freqs has 2 elements, but must have between 4 and 5 because most_common_elems has 2 elements
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.100000 is out of range 0.200000 to 0.300000
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency low bound 0.400000 cannot be greater than high bound 0.300000
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+ERROR:  most_common_elem_freqs null frequency -0.000100 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency -0.150000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency 1.500000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency -0.300000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency 3.000000 is out of range 0.0 to 1.0
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.400000 is out of range 0.200000 to 0.300000
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             | {3,1}             | {0.3,0.2,0.2,0.3,0}    |                      |                        |                  | 
+(1 row)
+
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac cannot be NULL when range_length_histogram is NOT NULL
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+ERROR:  range_length_histogram cannot be NULL when range_empty_frac is NOT NULL
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac -0.500000 is out of range 0.0 to 1.0
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac 1.500000 is out of range 0.0 to 1.0
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+ERROR:  range_length_histogram array values must be in ascending order, but Infinity > 499.000000
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      | {399,499,Infinity}     |              0.5 | 
+(1 row)
+
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac |        range_bounds_histogram        
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+--------------------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      |                        |                  | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  imported statistics must have a maximum of 5 slots but 6 given
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 5ac6e871f5..a7a4dfd411 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -28,7 +28,8 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
 # geometry depends on point, lseg, line, box, path, polygon, circle
 # horology depends on date, time, timetz, timestamp, timestamptz, interval
 # ----------
-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
+test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc stats_export_import
+
 
 # ----------
 # Load huge amounts of data
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..6292159665
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,730 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 8ecc02f2b9..72711d86d3 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29090,6 +29090,116 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>
+         , <parameter>attname</parameter> <type>name</type>
+         , <parameter>inherited</parameter> <type>boolean</type>
+         , <parameter>null_frac</parameter> <type>real</type>
+         , <parameter>avg_width</parameter> <type>integer</type>
+         , <parameter>n_distinct</parameter> <type>real</type>
+         [, <parameter>most_common_vals</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>histogram_bounds</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>correlation</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elems</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elem_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>elem_count_histogram</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_length_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_empty_frac</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_bounds_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ] )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>.  Aside from
+        <parameter>relation</parameter>, the parameters in this are all
+        derived from <structname>pg_stats</structname>, and the values
+        given are most often extracted from there.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From 29edf2917f3ee05819b544073a701b8898030411 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v12 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/include/fe_utils/stats_export.h  |  36 +++++
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 201 +++++++++++++++++++++++++++
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 100 ++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 10 files changed, 353 insertions(+), 2 deletions(-)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..f0dc7041f7
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..fd09e6ea8a
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,201 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.relpages, c.reltuples, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace";
+
+const char *export_attribute_stats_query_v17 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"s.range_length_histogram::text AS range_length_histogram, "
+	"s.range_empty_frac, "
+	"s.range_bounds_histogram::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"NULL::text AS range_length_histogram, NULL::real AS range_empty_frac, "
+	"NULL::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= 170000)
+		return export_attribute_stats_query_v17;
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %L::integer, %L::real, %L::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.relpages, r.reltuples, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT 1, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"inherited => %L::boolean, null_frac => %L::real, "
+			"avg_width => %L::integer, n_distinct => %L::real, "
+			"most_common_vals => %L::text, "
+			"most_common_freqs => %L::real[], "
+			"histogram_bounds => %L::text, "
+			"correlation => %L::real, "
+			"most_common_elems => %L::text, "
+			"most_common_elem_freqs => %L::real[], "
+			"elem_count_histogram => %L::real[], "
+			"range_length_histogram => %L::text, "
+			"range_empty_frac => %L::real, "
+			"range_bounds_histogram => %L::text)', "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.inherited, a.null_frac, a.avg_width, "
+			"a.n_distinct, a.most_common_vals, a.most_common_freqs, "
+			"a.histogram_bounds, a.correlation, "
+			"a.most_common_elems, a.most_common_elem_freqs, "
+			"a.elem_count_histogram, a.range_length_histogram, "
+			"a.range_empty_frac, a.range_bounds_histogram ) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index d275b31605..e368614745 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -428,6 +429,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1146,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7004,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7502,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10252,82 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	const char *stmtname = "relstats";
+	static bool prepared = false;
+	const char *values[2];
+	PGconn     *conn;
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	if (!prepared)
+	{
+		int		ver = PQserverVersion(conn);
+		char   *sql = exportRelationStatsSQL(ver);
+
+		if (sql == NULL)
+			pg_fatal("could not prepare stats export query for server version %d",
+					 ver);
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+			pg_fatal("prepared statement failed: %s",
+					 PQerrorMessage(conn));
+
+		free(sql);
+		prepared = true;
+	}
+
+	values[0] = fmtQualifiedId(dobj->namespace->dobj.name, dobj->name);
+	values[1] = NULL;
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+
+	/* Result set must be 1x1 */
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
+
+	if (PQntuples(res) != 1)
+		pg_fatal("statistics extraction expected one row, but got %d rows", 
+				 PQntuples(res));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, strdup(PQgetvalue(res, 0, 0)));
+	appendPQExpBufferStr(query, ";\n");
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	PQclear(res);
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16680,6 +16761,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind == RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16881,6 +16969,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16993,14 +17082,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+							 indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b3..69652aa205 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From 574d522503d36119886d95c91460d2260b10f2f6 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 21 Mar 2024 18:04:54 -0400
Subject: [PATCH v13 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics have to make
sense in the context of the new relation.

The statistics provided will be checked for suitability and consistency,
and will raise an error if found.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed. All stakind-based
statistics parameters has a default value of NULL.

In addition, the values provided are checked for consistency where
possible (values in acceptable ranges, array values in sub-ranges
defined within the array itself, array values in order, etc).

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   15 +
 src/include/statistics/statistics.h           |    2 +
 src/backend/catalog/system_functions.sql      |   18 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1108 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  939 ++++++++++++++
 src/test/regress/parallel_schedule            |    3 +-
 src/test/regress/sql/stats_export_import.sql  |  834 +++++++++++++
 doc/src/sgml/func.sgml                        |  110 ++
 10 files changed, 3031 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 71c74350a0..8b7a0d9b6e 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12180,4 +12180,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index fe2bb50f46..22be7e6653 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -636,6 +636,24 @@ LANGUAGE INTERNAL
 CALLED ON NULL INPUT VOLATILE PARALLEL SAFE
 AS 'pg_stat_reset_slru';
 
+CREATE OR REPLACE FUNCTION
+  pg_set_attribute_stats(relation oid, attname name, inherited bool,
+                         null_frac real, avg_width integer, n_distinct real,
+                         most_common_vals text DEFAULT NULL,
+                         most_common_freqs real[] DEFAULT NULL,
+                         histogram_bounds text DEFAULT NULL,
+                         correlation real DEFAULT NULL,
+                         most_common_elems text DEFAULT NULL,
+                         most_common_elem_freqs real[] DEFAULT NULL,
+                         elem_count_histogram real[] DEFAULT NULL,
+                         range_length_histogram text DEFAULT NULL,
+                         range_empty_frac real DEFAULT NULL,
+                         range_bounds_histogram text DEFAULT NULL)
+RETURNS void
+LANGUAGE INTERNAL
+CALLED ON NULL INPUT VOLATILE
+AS 'pg_set_attribute_stats';
+
 --
 -- The default permissions for functions mean that anyone can execute them.
 -- A number of functions shouldn't be executable by just anyone, but rather
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..3987425ea4
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1108 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/rangetypes.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+canModifyRelation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	const char *param_names[] = {
+		"relation",
+		"relpages",
+		"reltuples",
+		"relallvisible"
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* Any NULL parameter is an error */
+	for (int i = P_RELATION; i < P_NUM_PARAMS; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_VOID();
+}
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalue(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char	   *s = TextDatumGetCString(d);
+	Datum		out = FunctionCall3(finfo, CStringGetDatum(s),
+									ObjectIdGetDatum(typid),
+									Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+/*
+ * Convenience routine to handle a common pattern where two function
+ * parameters must either both be NULL or both NOT NULL.
+ */
+static bool
+has_arg_pair(FunctionCallInfo fcinfo, const char **pnames, int p1, int p2)
+{
+	/* if on param is NULL and the other NOT NULL, report an error */
+	if (PG_ARGISNULL(p1) != PG_ARGISNULL(p2))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be NULL when %s is NOT NULL",
+						pnames[(PG_ARGISNULL(p1)) ? p1 : p2],
+						pnames[(PG_ARGISNULL(p1)) ? p2 : p1])));
+
+	return (!PG_ARGISNULL(p1));
+}
+
+/*
+ * Test if the type is a scalar for MCELM purposes
+ */
+static bool
+type_is_scalar(Oid typid)
+{
+	HeapTuple	tp;
+	bool		result = false;
+
+	tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
+	if (HeapTupleIsValid(tp))
+	{
+		Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+
+		result = (!OidIsValid(typtup->typanalyze));
+		ReleaseSysCache(tp);
+	}
+	return result;
+}
+
+static int
+value_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	if (arr->ndims != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be a multidimensional array", name)));
+
+	return arr->dims[0];
+}
+
+/*
+ * Convenience routine to encapsulate all of the steps needed for any
+ * value array.
+ */
+static int
+value_not_null_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	const int	nelems = value_array_len(arr, name);
+
+	if (nelems > 0)
+	{
+		deconstruct_expanded_array(arr);
+
+		/* if there's a nulls array, all values must be false */
+		if (arr->dnulls != NULL)
+			for (int i = 0; i < nelems; i++)
+				if (arr->dnulls[i])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array cannot contain NULL values", name)));
+	}
+
+	return nelems;
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * The function takes input parameters that correspond to columns in the view
+ * pg_stats.
+ *
+ * Of those, the columns attname, inherited, null_frac, avg_width, and
+ * n_distinct all correspond to NOT NULL columns in pg_statistic. These
+ * parameters have no default value and passing NULL to them will result
+ * in an error.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will raise an error. Likewise for setting inherited statistics
+ * on a table that is not partitioned.
+ *
+ * The remaining parameters all belong to a specific stakind. Some stakinds
+ * have multiple parameters, and in those cases both parameters must be
+ * NOT NULL or both NULL, otherwise an error will be raised.
+ *
+ * Omitting a parameter or explicitly passing NULL means that that particular
+ * stakind is not associated with the attribute.
+ *
+ * Parameters that are NOT NULL will be inspected for consistency checks,
+ * any of which can raise an error.
+ *
+ * Parameters corresponding to ANYARRAY columns are instead passed in as text
+ * values, which is a valid input string for an array of the type or basetype
+ * of the attribute. Any error generated by the array_in() function will in
+ * turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *param_names[] = {
+		"relation",
+		"attname",
+		"inherited",
+		"null_frac",
+		"avg_width",
+		"n_distinct",
+		"most_common_vals",
+		"most_common_freqs",
+		"histogram_bounds",
+		"correlation",
+		"most_common_elems",
+		"most_common_elem_freqs",
+		"elem_count_histogram",
+		"range_length_histogram",
+		"range_empty_frac",
+		"range_bounds_histogram"
+	};
+
+	Oid			relid;
+	Name		attname;
+	bool		inherited;
+	Relation	rel;
+	HeapTuple	ctup;
+	HeapTuple	atup;
+	Form_pg_class pgcform;
+
+	TypeCacheEntry *typcache;
+	const int	operator_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	const float4 frac_min = 0.0;
+	const float4 frac_max = 1.0;
+	float4		null_frac;
+	const int	avg_width_min = 0;
+	int			avg_width;
+	const float4 n_distinct_min = -1.0;
+	float4		n_distinct;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+	FmgrInfo	finfo;
+
+	bool		has_mcv;
+	bool		has_mc_elems;
+	bool		has_rl_hist;
+	int			stakind_count;
+
+	int			k = 0;
+
+	/*
+	 * A null in a required parameter is an error.
+	 */
+	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	/*
+	 * Check all parameter pairs up front.
+	 */
+	has_mcv = has_arg_pair(fcinfo, param_names,
+						   P_MC_VALS, P_MC_FREQS);
+	has_mc_elems = has_arg_pair(fcinfo, param_names,
+								P_MC_ELEMS, P_MC_ELEM_FREQS);
+	has_rl_hist = has_arg_pair(fcinfo, param_names,
+							   P_RANGE_LENGTH_HIST, P_RANGE_EMPTY_FRAC);
+
+	/*
+	 * If a caller specifies more stakind-stats than we have slots to store
+	 * them, raise an error.
+	 */
+	stakind_count = (int) has_mcv + (int) has_mc_elems + (int) has_rl_hist +
+		(int) !PG_ARGISNULL(P_HIST_BOUNDS) +
+		(int) !PG_ARGISNULL(P_CORRELATION) +
+		(int) !PG_ARGISNULL(P_ELEM_COUNT_HIST) +
+		(int) !PG_ARGISNULL(P_RANGE_BOUNDS_HIST);
+
+	if (stakind_count > STATISTIC_NUM_SLOTS)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("imported statistics must have a maximum of %d slots "
+						"but %d given",
+						STATISTIC_NUM_SLOTS, stakind_count)));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	/* Test existence of Relation */
+	ctup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+	ReleaseSysCache(ctup);
+
+	/*
+	 * Test existence of attribute
+	 */
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	atup = SearchSysCache2(ATTNAME,
+						   ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	/* Attribute not found nowhere to import the stats to */
+	if (!HeapTupleIsValid(atup))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s has no attname %s",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s attname %s is dropped",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	/* Test inherited */
+	inherited = PG_GETARG_BOOL(P_INHERITED);
+	if (inherited &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s is not partitioned, cannot accept inherited stats",
+						RelationGetRelationName(rel))));
+
+	/*
+	 * Fetch datatype information, this is needed to derive the proper staopN
+	 * and stacollN values.
+	 *
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+	typcache = lookup_type_cache(typid, operator_flags);
+	ltopr = typcache->lt_opr;
+	eqopr = typcache->eq_opr;
+
+	/*
+	 * if it's a range type, swap the subtype for the base type, otherwise get
+	 * the base element type
+	 */
+	if (type_is_range(typid))
+		basetypid = get_range_subtype(typid);
+	else
+		basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+	{
+		TypeCacheEntry *bentry = lookup_type_cache(basetypid, operator_flags);
+
+		baseltopr = bentry->lt_opr;
+		baseeqopr = bentry->eq_opr;
+	}
+
+	/* P_HIST_BOUNDS and P_CORRELATION must have a < operator */
+	if (baseltopr == InvalidOid)
+		for (int i = P_HIST_BOUNDS; i <= P_CORRELATION; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s cannot "
+								"have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Scalar types can't have P_MC_ELEMS, P_MC_ELEM_FREQS, P_ELEM_COUNT_HIST */
+	/* TODO any other types we can exclude? */
+	if (type_is_scalar(typid))
+		for (int i = P_MC_ELEMS; i <= P_ELEM_COUNT_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is a scalar type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Only range types can have P_RANGE_x */
+	if ((!type_is_range(typid)) && (!type_is_multirange(typid)))
+		for (int i = P_RANGE_LENGTH_HIST; i <= P_RANGE_BOUNDS_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is not a range type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/*
+	 * Statistical parameters that must pass data validity tests
+	 */
+	null_frac = PG_GETARG_FLOAT4(P_NULL_FRAC);
+	if ((null_frac < frac_min) || (null_frac > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						param_names[P_NULL_FRAC], null_frac,
+						frac_min, frac_max)));
+
+	avg_width = PG_GETARG_INT32(P_AVG_WIDTH);
+	if (avg_width < avg_width_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %d must be >= %d",
+						param_names[P_AVG_WIDTH], avg_width, avg_width_min)));
+
+	n_distinct = PG_GETARG_FLOAT4(P_N_DISTINCT);
+	if (n_distinct < n_distinct_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f must be >= %.1f",
+						param_names[P_N_DISTINCT], n_distinct,
+						n_distinct_min)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS && MC_FREQS => STATISTIC_KIND_MCV */
+	if (has_mcv)
+	{
+		const char *freqsname = param_names[P_MC_FREQS];
+		const char *valsname = param_names[P_MC_VALS];
+		Datum		freqs = PG_GETARG_DATUM(P_MC_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_VALS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			nvals = value_array_len(valsarr, valsname);
+		int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+
+		if (nfreqs != nvals)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s has %d elements, but %s has %d elements, "
+							"but they must be equal",
+							freqsname, nfreqs,
+							valsname, nvals)));
+
+		/*
+		 * check that freqs sum to <= 1.0 or some number slightly higer to
+		 * allow for compounded rounding errors.
+		 */
+
+
+		if (nfreqs >= 1)
+		{
+			const float4 freqsummax = 1.1;
+
+			float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+			float4		freqsum = prev;
+
+			for (int i = 1; i < nfreqs; i++)
+			{
+				float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+				if (f > prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in descending "
+									"order, but %f > %f",
+									freqsname, f, prev)));
+
+				freqsum += f;
+				prev = f;
+			}
+
+			if (freqsum > freqsummax)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("The sum of elements in %s must not exceed "
+								"%.2f but is %f",
+								freqsname, freqsummax, freqsum)));
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(eqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = freqs;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = vals;
+
+		k++;
+	}
+
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		const char *statname = param_names[P_HIST_BOUNDS];
+		Datum		strvalue = PG_GETARG_DATUM(P_HIST_BOUNDS);
+		Datum		stavalues = cast_stavalue(&finfo, strvalue, basetypid, typmod);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+		SortSupportData ssupd;
+
+		int			nelems = value_not_null_array_len(arr, statname);
+
+
+
+		memset(&ssupd, 0, sizeof(ssupd));
+		ssupd.ssup_cxt = CurrentMemoryContext;
+		ssupd.ssup_collation = typcoll;
+		ssupd.ssup_nulls_first = false;
+		ssupd.abbreviate = false;
+
+		PrepareSortSupportFromOrderingOp(baseltopr, &ssupd);
+
+		/*
+		 * This is a histogram, which means that the values must be in
+		 * monotonically non-decreasing order. If we every find a case where
+		 * [n] > [n+1], raise an error.
+		 */
+		for (int i = 1; i < nelems; i++)
+		{
+			Datum		a = arr->dvalues[i - 1];
+			Datum		b = arr->dvalues[i];
+
+			if (ssupd.comparator(a, b, &ssupd) > 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s values must be in ascending order %s",
+								statname, TextDatumGetCString(strvalue))));
+
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		const char *statname = param_names[P_CORRELATION];
+		Datum		elem = PG_GETARG_DATUM(P_CORRELATION);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		const float4 corr_min = -1.0;
+		const float4 corr_max = 1.0;
+		float4		corr = PG_GETARG_FLOAT4(P_CORRELATION);
+
+		if ((corr < corr_min) || (corr > corr_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %f is out of range %.1f to %.1f",
+							statname, corr, corr_min, corr_max)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS && MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if (has_mc_elems)
+	{
+		const char *elemsname = param_names[P_MC_ELEMS];
+		const char *freqsname = param_names[P_MC_ELEM_FREQS];
+		Datum		freqs = PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+		int			nvals = value_not_null_array_len(valsarr, elemsname);
+
+		/*
+		 * The mcelem freqs array has either 2 or 3 additional values: the min
+		 * frequency, the max frequency, the optional null frequency.
+		 */
+		int			nfreqsmin = nvals + 2;
+		int			nfreqsmax = nvals + 3;
+
+		float4		freqlowbound;
+		float4		freqhighbound;
+
+		if (nfreqs > 0)
+		{
+			if ((nfreqs < nfreqsmin) || (nfreqs > nfreqsmax))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s has %d elements, but must have between "
+								"%d and %d because %s has %d elements",
+								freqsname, nfreqs, nfreqsmin, nfreqsmax,
+								elemsname, nvals)));
+
+			/*
+			 * the freqlowbound and freqhighbound must themselves be valid
+			 * percentages
+			 */
+
+			/* first freq element past the length of the values is the min */
+			freqlowbound = DatumGetFloat4(freqsarr->dvalues[nvals]);
+			if ((freqlowbound < frac_min) || (freqlowbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of "
+								"range %.1f to %.1f",
+								freqsname, "minimum", freqlowbound,
+								frac_min, frac_max)));
+
+			/* second freq element past the length of the values is the max */
+			freqhighbound = DatumGetFloat4(freqsarr->dvalues[nvals + 1]);
+			if ((freqhighbound < frac_min) || (freqhighbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of "
+								"range %.1f to %.1f",
+								freqsname, "maximum", freqhighbound,
+								frac_min, frac_max)));
+
+			/* low bound must be < high bound */
+			if (freqlowbound > freqhighbound)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s frequency low bound %f cannot be greater "
+								"than high bound %f",
+								freqsname, freqlowbound, freqhighbound)));
+
+			/*
+			 * third freq element past the length of the values is the null
+			 * frac
+			 */
+			if (nfreqs == nvals + 3)
+			{
+				float4		freqnullpct;
+
+				freqnullpct = DatumGetFloat4(freqsarr->dvalues[nvals + 2]);
+
+				if ((freqnullpct < frac_min) || (freqnullpct > frac_max))
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s %s frequency %f is out of "
+									"range %.1f to %.1f",
+									freqsname, "null", freqnullpct,
+									frac_min, frac_max)));
+			}
+
+			/*
+			 * All the freqs that match up to a val must bet between low/high
+			 * bounds (which is never less strict than frac_min/frac_max) and
+			 * must be in monotonically non-increasing order.
+			 *
+			 * Also, these frequencies do not sum to a number <= 1.0 as is the
+			 * case with MC_FREQS.
+			 */
+			if (nvals > 1)
+			{
+				float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+
+				for (int i = 1; i < nvals; i++)
+				{
+					float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+					if ((f < freqlowbound) || (f > freqhighbound))
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("%s frequency %f is out of range "
+										"%f to %f",
+										freqsname, f,
+										freqlowbound, freqhighbound)));
+					if (f > prev)
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("%s array values must be in "
+										"descending order, but %f > %f",
+										freqsname, f, prev)));
+
+					prev = f;
+				}
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+						  basetypid, typmod);
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		const char *statname = param_names[P_ELEM_COUNT_HIST];
+		Datum		stanumbers = PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stanumbers);
+
+		const float4 last_min = 0.0;
+
+		int			nelems = value_not_null_array_len(arr, statname);
+		float4		last;
+
+		/* Last element must be >= 0 */
+		last = DatumGetFloat4(arr->dvalues[nelems - 1]);
+		if (last < last_min)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s has last element %f < %.1f",
+							statname, last, last_min)));
+
+		/* all other elements must be monotonically nondecreasing */
+		if (nelems > 1)
+		{
+			float4		prev = DatumGetFloat4(arr->dvalues[0]);
+
+			for (int i = 1; i < nelems - 1; i++)
+			{
+				float4		f = DatumGetFloat4(arr->dvalues[i]);
+
+				if (f < prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in ascending "
+									"order, but %f > %f",
+									statname, prev, f)));
+
+				prev = f;
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * RANGE_BOUNDS_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM even though
+	 * it is numerically greater, and all other stakinds appear in numerical
+	 * order. We duplicate this quirk to make before/after tests of
+	 * pg_statistic records easier.
+	 *
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+		const char *statname = param_names[P_RANGE_BOUNDS_HIST];
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST);
+		Datum		stavalues = cast_stavalue(&finfo, strvalue, typid, typmod);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+
+		int			nelems = value_not_null_array_len(arr, statname);
+
+		/*
+		 * The values in this array are range types, but in fact it's using
+		 * range types to have two parallel arrays with inclusive/exclusive
+		 * bounds, and those two arrays must each be monotonically
+		 * nondecreasing. So basically we want to test that: lower_bound(N) <=
+		 * lower_bound(N+1) and upper_bound(N) <= upper_bound(N+1)
+		 */
+		if (nelems > 1)
+		{
+			RangeType  *prevrange = DatumGetRangeTypeP(arr->dvalues[0]);
+			RangeBound	prevlower;
+			RangeBound	prevupper;
+			bool		empty;
+
+			range_deserialize(typcache, prevrange, &prevlower,
+							  &prevupper, &empty);
+
+
+			for (int i = 1; i < nelems; i++)
+			{
+				RangeType  *range = DatumGetRangeTypeP(arr->dvalues[i]);
+				RangeBound	lower;
+				RangeBound	upper;
+
+				range_deserialize(typcache, range, &lower, &upper, &empty);
+
+				if (range_cmp_bounds(typcache, &prevlower, &lower) == 1)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array %s bounds must be in ascending order",
+									statname, "lower")));
+
+				if (range_cmp_bounds(typcache, &prevupper, &upper) == 1)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array %s bounds must be in ascending order",
+									statname, "upper")));
+
+				memcpy(&lower, &prevlower, sizeof(RangeBound));
+				memcpy(&upper, &prevupper, sizeof(RangeBound));
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/*
+	 * P_RANGE_LENGTH_HIST && P_RANGE_EMPTY_FRAC =>
+	 * STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM
+	 */
+	if (has_rl_hist)
+	{
+		const char *histname = param_names[P_RANGE_LENGTH_HIST];
+		const char *fracname = param_names[P_RANGE_EMPTY_FRAC];
+		Datum		elem = PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC);
+		Datum		rlhist = PG_GETARG_DATUM(P_RANGE_LENGTH_HIST);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+		float4		frac = DatumGetFloat4(elem);
+		Datum		stavalue;
+
+		ExpandedArrayHeader *arr;
+		int			nelems;
+
+		if ((frac < frac_min) || (frac > frac_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %f is out of range %.1f to %.1f",
+							fracname, frac, frac_min, frac_max)));
+
+		/*
+		 * RANGE_LENGTH_HIST is stored in an anyarray, but it is known to be
+		 * of type float8[]. It is also a histogram, so it must be in
+		 * monotonically nondecreasing order.
+		 */
+		stavalue = cast_stavalue(&finfo, rlhist, FLOAT8OID, typmod);
+
+		arr = DatumGetExpandedArray(stavalue);
+		nelems = value_not_null_array_len(arr, histname);
+
+		if (nelems > 1)
+		{
+			float8		prev = DatumGetFloat8(arr->dvalues[0]);
+
+			for (int i = 1; i < nelems; i++)
+			{
+				float8		f = DatumGetFloat8(arr->dvalues[i]);
+
+				if (f < prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in ascending "
+									"order, but %f > %f",
+									histname, prev, f)));
+
+				prev = f;
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalue;
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for (; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_INHERITED));
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic];
+
+		for (int i = 0; i < Natts_pg_statistic; i++)
+			replaces[i] = true;
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(atup);
+	PG_RETURN_VOID();
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..32b9e7ca11
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,939 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ 
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+ERROR:  relpages cannot be NULL
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  could not open relation with OID 0
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  relation cannot be NULL
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  attname cannot be NULL
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  inherited cannot be NULL
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  Relation test is not partitioned, cannot accept inherited stats
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+ERROR:  n_distinct cannot be NULL
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 |                  |                   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac -0.100000 is out of range 0.0 to 1.0
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac 1.100000 is out of range 0.0 to 1.0
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width -1 must be >= 0
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+ERROR:  n_distinct -1.100000 must be >= -1.0
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_vals cannot be NULL when most_common_freqs is NOT NULL
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+ERROR:  most_common_freqs cannot be NULL when most_common_vals is NOT NULL
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+ERROR:  most_common_freqs has 2 elements, but most_common_vals has 3 elements, but they must be equal
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+ERROR:  The sum of elements in most_common_freqs must not exceed 1.10 but is 1.400000
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 | {2,1,3}          | {0.3,0.25,0.05}   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+ERROR:  histogram_bounds array cannot contain NULL values
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+ERROR:  histogram_bounds values must be in ascending order {1,20,3,4}
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   | {1,2,3,4}        |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+ERROR:  correlation -1.100000 is out of range -1.0 to 1.0
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+ERROR:  correlation 1.100000 is out of range -1.0 to 1.0
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type most_common_elems
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+ERROR:  most_common_elem_freqs cannot be NULL when most_common_elems is NOT NULL
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_elems cannot be NULL when most_common_elem_freqs is NOT NULL
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+ERROR:  most_common_elem_freqs has 2 elements, but must have between 4 and 5 because most_common_elems has 2 elements
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.100000 is out of range 0.200000 to 0.300000
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency low bound 0.400000 cannot be greater than high bound 0.300000
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+ERROR:  most_common_elem_freqs null frequency -0.000100 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency -0.150000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency 1.500000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency -0.300000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency 3.000000 is out of range 0.0 to 1.0
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.400000 is out of range 0.200000 to 0.300000
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             | {three,one}       | {0.3,0.2,0.2,0.3,0}    |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type elem_count_histogram
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array cannot contain NULL values
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array values must be in ascending order, but 1.000000 > 0.000000
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_length_histogram
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac cannot be NULL when range_length_histogram is NOT NULL
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+ERROR:  range_length_histogram cannot be NULL when range_empty_frac is NOT NULL
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac -0.500000 is out of range 0.0 to 1.0
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac 1.500000 is out of range 0.0 to 1.0
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+ERROR:  range_length_histogram array values must be in ascending order, but Infinity > 499.000000
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      | {399,499,Infinity}     |              0.5 | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_bounds_histogram
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array lower bounds must be in ascending order
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array upper bounds must be in ascending order
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac |        range_bounds_histogram        
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+--------------------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      |                        |                  | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  imported statistics must have a maximum of 5 slots but 6 given
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 5ac6e871f5..a7a4dfd411 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -28,7 +28,8 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
 # geometry depends on point, lseg, line, box, path, polygon, circle
 # horology depends on date, time, timetz, timestamp, timestamptz, interval
 # ----------
-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
+test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc stats_export_import
+
 
 # ----------
 # Load huge amounts of data
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..b3f17373d3
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,834 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 8ecc02f2b9..72711d86d3 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29090,6 +29090,116 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>
+         , <parameter>attname</parameter> <type>name</type>
+         , <parameter>inherited</parameter> <type>boolean</type>
+         , <parameter>null_frac</parameter> <type>real</type>
+         , <parameter>avg_width</parameter> <type>integer</type>
+         , <parameter>n_distinct</parameter> <type>real</type>
+         [, <parameter>most_common_vals</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>histogram_bounds</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>correlation</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elems</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elem_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>elem_count_histogram</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_length_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_empty_frac</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_bounds_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ] )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>.  Aside from
+        <parameter>relation</parameter>, the parameters in this are all
+        derived from <structname>pg_stats</structname>, and the values
+        given are most often extracted from there.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From ce99e03de965e4a14f0c5f9487ba484b3b91d544 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v13 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/include/fe_utils/stats_export.h  |  36 +++++
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 201 +++++++++++++++++++++++++++
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 100 ++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 10 files changed, 353 insertions(+), 2 deletions(-)
 create mode 100644 src/include/fe_utils/stats_export.h
 create mode 100644 src/fe_utils/stats_export.c

diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 0000000000..f0dc7041f7
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+
+#endif
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f..c734f9f6d3 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2c..fce503f641 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 0000000000..fd09e6ea8a
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,201 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.relpages, c.reltuples, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace";
+
+const char *export_attribute_stats_query_v17 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"s.range_length_histogram::text AS range_length_histogram, "
+	"s.range_empty_frac, "
+	"s.range_bounds_histogram::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"NULL::text AS range_length_histogram, NULL::real AS range_empty_frac, "
+	"NULL::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= 170000)
+		return export_attribute_stats_query_v17;
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %L::integer, %L::real, %L::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.relpages, r.reltuples, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT 1, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"inherited => %L::boolean, null_frac => %L::real, "
+			"avg_width => %L::integer, n_distinct => %L::real, "
+			"most_common_vals => %L::text, "
+			"most_common_freqs => %L::real[], "
+			"histogram_bounds => %L::text, "
+			"correlation => %L::real, "
+			"most_common_elems => %L::text, "
+			"most_common_elem_freqs => %L::real[], "
+			"elem_count_histogram => %L::real[], "
+			"range_length_histogram => %L::text, "
+			"range_empty_frac => %L::real, "
+			"range_bounds_histogram => %L::text)', "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.inherited, a.null_frac, a.avg_width, "
+			"a.n_distinct, a.most_common_vals, a.most_common_freqs, "
+			"a.histogram_bounds, a.correlation, "
+			"a.most_common_elems, a.most_common_elem_freqs, "
+			"a.elem_count_histogram, a.range_length_histogram, "
+			"a.range_empty_frac, a.range_bounds_histogram ) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index d275b31605..e368614745 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -428,6 +429,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1146,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7004,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7502,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10252,82 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	const char *stmtname = "relstats";
+	static bool prepared = false;
+	const char *values[2];
+	PGconn     *conn;
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	if (!prepared)
+	{
+		int		ver = PQserverVersion(conn);
+		char   *sql = exportRelationStatsSQL(ver);
+
+		if (sql == NULL)
+			pg_fatal("could not prepare stats export query for server version %d",
+					 ver);
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+			pg_fatal("prepared statement failed: %s",
+					 PQerrorMessage(conn));
+
+		free(sql);
+		prepared = true;
+	}
+
+	values[0] = fmtQualifiedId(dobj->namespace->dobj.name, dobj->name);
+	values[1] = NULL;
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+
+	/* Result set must be 1x1 */
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
+
+	if (PQntuples(res) != 1)
+		pg_fatal("statistics extraction expected one row, but got %d rows", 
+				 PQntuples(res));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, strdup(PQgetvalue(res, 0, 0)));
+	appendPQExpBufferStr(query, ";\n");
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	PQclear(res);
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16680,6 +16761,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind == RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16881,6 +16969,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16993,14 +17082,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+							 indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b3..69652aa205 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From 686f748f3f92d3f9dc77b74ff1c35fed758e0dd8 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 21 Mar 2024 18:04:54 -0400
Subject: [PATCH 1/4] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics have to make
sense in the context of the new relation.

The statistics provided will be checked for suitability and consistency,
and will raise an error if found.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed. All stakind-based
statistics parameters has a default value of NULL.

In addition, the values provided are checked for consistency where
possible (values in acceptable ranges, array values in sub-ranges
defined within the array itself, array values in order, etc).

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 doc/src/sgml/func.sgml                        |  110 ++
 src/backend/catalog/system_functions.sql      |   18 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1108 +++++++++++++++++
 src/include/catalog/pg_proc.dat               |   15 +
 src/include/statistics/statistics.h           |    2 +
 .../regress/expected/stats_export_import.out  |  939 ++++++++++++++
 src/test/regress/parallel_schedule            |    3 +-
 src/test/regress/sql/stats_export_import.sql  |  834 +++++++++++++
 10 files changed, 3031 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 8ecc02f2b90..72711d86d37 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29090,6 +29090,116 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back through
+        normal transaction processing.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>
+         , <parameter>attname</parameter> <type>name</type>
+         , <parameter>inherited</parameter> <type>boolean</type>
+         , <parameter>null_frac</parameter> <type>real</type>
+         , <parameter>avg_width</parameter> <type>integer</type>
+         , <parameter>n_distinct</parameter> <type>real</type>
+         [, <parameter>most_common_vals</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>histogram_bounds</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>correlation</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elems</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elem_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>elem_count_histogram</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_length_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_empty_frac</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_bounds_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ] )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>.  Aside from
+        <parameter>relation</parameter>, the parameters in this are all
+        derived from <structname>pg_stats</structname>, and the values
+        given are most often extracted from there.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index fe2bb50f46d..22be7e66535 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -636,6 +636,24 @@ LANGUAGE INTERNAL
 CALLED ON NULL INPUT VOLATILE PARALLEL SAFE
 AS 'pg_stat_reset_slru';
 
+CREATE OR REPLACE FUNCTION
+  pg_set_attribute_stats(relation oid, attname name, inherited bool,
+                         null_frac real, avg_width integer, n_distinct real,
+                         most_common_vals text DEFAULT NULL,
+                         most_common_freqs real[] DEFAULT NULL,
+                         histogram_bounds text DEFAULT NULL,
+                         correlation real DEFAULT NULL,
+                         most_common_elems text DEFAULT NULL,
+                         most_common_elem_freqs real[] DEFAULT NULL,
+                         elem_count_histogram real[] DEFAULT NULL,
+                         range_length_histogram text DEFAULT NULL,
+                         range_empty_frac real DEFAULT NULL,
+                         range_bounds_histogram text DEFAULT NULL)
+RETURNS void
+LANGUAGE INTERNAL
+CALLED ON NULL INPUT VOLATILE
+AS 'pg_set_attribute_stats';
+
 --
 -- The default permissions for functions mean that anyone can execute them.
 -- A number of functions shouldn't be executable by just anyone, but rather
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c27973..e4f8ab7c4f5 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50a..331e82c776b 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 00000000000..3987425ea4d
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1108 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/rangetypes.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+canModifyRelation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	const char *param_names[] = {
+		"relation",
+		"relpages",
+		"reltuples",
+		"relallvisible"
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* Any NULL parameter is an error */
+	for (int i = P_RELATION; i < P_NUM_PARAMS; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_VOID();
+}
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalue(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char	   *s = TextDatumGetCString(d);
+	Datum		out = FunctionCall3(finfo, CStringGetDatum(s),
+									ObjectIdGetDatum(typid),
+									Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+/*
+ * Convenience routine to handle a common pattern where two function
+ * parameters must either both be NULL or both NOT NULL.
+ */
+static bool
+has_arg_pair(FunctionCallInfo fcinfo, const char **pnames, int p1, int p2)
+{
+	/* if on param is NULL and the other NOT NULL, report an error */
+	if (PG_ARGISNULL(p1) != PG_ARGISNULL(p2))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be NULL when %s is NOT NULL",
+						pnames[(PG_ARGISNULL(p1)) ? p1 : p2],
+						pnames[(PG_ARGISNULL(p1)) ? p2 : p1])));
+
+	return (!PG_ARGISNULL(p1));
+}
+
+/*
+ * Test if the type is a scalar for MCELM purposes
+ */
+static bool
+type_is_scalar(Oid typid)
+{
+	HeapTuple	tp;
+	bool		result = false;
+
+	tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
+	if (HeapTupleIsValid(tp))
+	{
+		Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+
+		result = (!OidIsValid(typtup->typanalyze));
+		ReleaseSysCache(tp);
+	}
+	return result;
+}
+
+static int
+value_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	if (arr->ndims != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be a multidimensional array", name)));
+
+	return arr->dims[0];
+}
+
+/*
+ * Convenience routine to encapsulate all of the steps needed for any
+ * value array.
+ */
+static int
+value_not_null_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	const int	nelems = value_array_len(arr, name);
+
+	if (nelems > 0)
+	{
+		deconstruct_expanded_array(arr);
+
+		/* if there's a nulls array, all values must be false */
+		if (arr->dnulls != NULL)
+			for (int i = 0; i < nelems; i++)
+				if (arr->dnulls[i])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array cannot contain NULL values", name)));
+	}
+
+	return nelems;
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * The function takes input parameters that correspond to columns in the view
+ * pg_stats.
+ *
+ * Of those, the columns attname, inherited, null_frac, avg_width, and
+ * n_distinct all correspond to NOT NULL columns in pg_statistic. These
+ * parameters have no default value and passing NULL to them will result
+ * in an error.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will raise an error. Likewise for setting inherited statistics
+ * on a table that is not partitioned.
+ *
+ * The remaining parameters all belong to a specific stakind. Some stakinds
+ * have multiple parameters, and in those cases both parameters must be
+ * NOT NULL or both NULL, otherwise an error will be raised.
+ *
+ * Omitting a parameter or explicitly passing NULL means that that particular
+ * stakind is not associated with the attribute.
+ *
+ * Parameters that are NOT NULL will be inspected for consistency checks,
+ * any of which can raise an error.
+ *
+ * Parameters corresponding to ANYARRAY columns are instead passed in as text
+ * values, which is a valid input string for an array of the type or basetype
+ * of the attribute. Any error generated by the array_in() function will in
+ * turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of columns that cannot be null */
+	const char *param_names[] = {
+		"relation",
+		"attname",
+		"inherited",
+		"null_frac",
+		"avg_width",
+		"n_distinct",
+		"most_common_vals",
+		"most_common_freqs",
+		"histogram_bounds",
+		"correlation",
+		"most_common_elems",
+		"most_common_elem_freqs",
+		"elem_count_histogram",
+		"range_length_histogram",
+		"range_empty_frac",
+		"range_bounds_histogram"
+	};
+
+	Oid			relid;
+	Name		attname;
+	bool		inherited;
+	Relation	rel;
+	HeapTuple	ctup;
+	HeapTuple	atup;
+	Form_pg_class pgcform;
+
+	TypeCacheEntry *typcache;
+	const int	operator_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR;
+
+	Oid			typid;
+	int32		typmod;
+	Oid			typcoll;
+	Oid			eqopr;
+	Oid			ltopr;
+	Oid			basetypid;
+	Oid			baseeqopr;
+	Oid			baseltopr;
+
+	const float4 frac_min = 0.0;
+	const float4 frac_max = 1.0;
+	float4		null_frac;
+	const int	avg_width_min = 0;
+	int			avg_width;
+	const float4 n_distinct_min = -1.0;
+	float4		n_distinct;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	Relation	sd;
+	HeapTuple	oldtup;
+	CatalogIndexState indstate;
+	HeapTuple	stup;
+	Form_pg_attribute attr;
+
+	FmgrInfo	finfo;
+
+	bool		has_mcv;
+	bool		has_mc_elems;
+	bool		has_rl_hist;
+	int			stakind_count;
+
+	int			k = 0;
+
+	/*
+	 * A null in a required parameter is an error.
+	 */
+	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	/*
+	 * Check all parameter pairs up front.
+	 */
+	has_mcv = has_arg_pair(fcinfo, param_names,
+						   P_MC_VALS, P_MC_FREQS);
+	has_mc_elems = has_arg_pair(fcinfo, param_names,
+								P_MC_ELEMS, P_MC_ELEM_FREQS);
+	has_rl_hist = has_arg_pair(fcinfo, param_names,
+							   P_RANGE_LENGTH_HIST, P_RANGE_EMPTY_FRAC);
+
+	/*
+	 * If a caller specifies more stakind-stats than we have slots to store
+	 * them, raise an error.
+	 */
+	stakind_count = (int) has_mcv + (int) has_mc_elems + (int) has_rl_hist +
+		(int) !PG_ARGISNULL(P_HIST_BOUNDS) +
+		(int) !PG_ARGISNULL(P_CORRELATION) +
+		(int) !PG_ARGISNULL(P_ELEM_COUNT_HIST) +
+		(int) !PG_ARGISNULL(P_RANGE_BOUNDS_HIST);
+
+	if (stakind_count > STATISTIC_NUM_SLOTS)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("imported statistics must have a maximum of %d slots "
+						"but %d given",
+						STATISTIC_NUM_SLOTS, stakind_count)));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	/* Test existence of Relation */
+	ctup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!canModifyRelation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+	ReleaseSysCache(ctup);
+
+	/*
+	 * Test existence of attribute
+	 */
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	atup = SearchSysCache2(ATTNAME,
+						   ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	/* Attribute not found nowhere to import the stats to */
+	if (!HeapTupleIsValid(atup))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s has no attname %s",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s attname %s is dropped",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	/* Test inherited */
+	inherited = PG_GETARG_BOOL(P_INHERITED);
+	if (inherited &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) &&
+		(rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s is not partitioned, cannot accept inherited stats",
+						RelationGetRelationName(rel))));
+
+	/*
+	 * Fetch datatype information, this is needed to derive the proper staopN
+	 * and stacollN values.
+	 *
+	 * If this relation is an index and that index has expressions in it, and
+	 * the attnum specified is known to be an expression, then we must walk
+	 * the list attributes up to the specified attnum to get the right
+	 * expression.
+	 */
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			typcoll = attr->attcollation;
+		else
+			typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		typmod = attr->atttypmod;
+		typcoll = attr->attcollation;
+	}
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+	typcache = lookup_type_cache(typid, operator_flags);
+	ltopr = typcache->lt_opr;
+	eqopr = typcache->eq_opr;
+
+	/*
+	 * if it's a range type, swap the subtype for the base type, otherwise get
+	 * the base element type
+	 */
+	if (type_is_range(typid))
+		basetypid = get_range_subtype(typid);
+	else
+		basetypid = get_base_element_type(typid);
+
+	if (basetypid == InvalidOid)
+	{
+		/* type is its own base type */
+		basetypid = typid;
+		baseltopr = ltopr;
+		baseeqopr = eqopr;
+	}
+	else
+	{
+		TypeCacheEntry *bentry = lookup_type_cache(basetypid, operator_flags);
+
+		baseltopr = bentry->lt_opr;
+		baseeqopr = bentry->eq_opr;
+	}
+
+	/* P_HIST_BOUNDS and P_CORRELATION must have a < operator */
+	if (baseltopr == InvalidOid)
+		for (int i = P_HIST_BOUNDS; i <= P_CORRELATION; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s cannot "
+								"have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Scalar types can't have P_MC_ELEMS, P_MC_ELEM_FREQS, P_ELEM_COUNT_HIST */
+	/* TODO any other types we can exclude? */
+	if (type_is_scalar(typid))
+		for (int i = P_MC_ELEMS; i <= P_ELEM_COUNT_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is a scalar type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Only range types can have P_RANGE_x */
+	if ((!type_is_range(typid)) && (!type_is_multirange(typid)))
+		for (int i = P_RANGE_LENGTH_HIST; i <= P_RANGE_BOUNDS_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is not a range type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/*
+	 * Statistical parameters that must pass data validity tests
+	 */
+	null_frac = PG_GETARG_FLOAT4(P_NULL_FRAC);
+	if ((null_frac < frac_min) || (null_frac > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						param_names[P_NULL_FRAC], null_frac,
+						frac_min, frac_max)));
+
+	avg_width = PG_GETARG_INT32(P_AVG_WIDTH);
+	if (avg_width < avg_width_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %d must be >= %d",
+						param_names[P_AVG_WIDTH], avg_width, avg_width_min)));
+
+	n_distinct = PG_GETARG_FLOAT4(P_N_DISTINCT);
+	if (n_distinct < n_distinct_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f must be >= %.1f",
+						param_names[P_N_DISTINCT], n_distinct,
+						n_distinct_min)));
+
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attr->attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS && MC_FREQS => STATISTIC_KIND_MCV */
+	if (has_mcv)
+	{
+		const char *freqsname = param_names[P_MC_FREQS];
+		const char *valsname = param_names[P_MC_VALS];
+		Datum		freqs = PG_GETARG_DATUM(P_MC_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_VALS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			nvals = value_array_len(valsarr, valsname);
+		int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+
+		if (nfreqs != nvals)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s has %d elements, but %s has %d elements, "
+							"but they must be equal",
+							freqsname, nfreqs,
+							valsname, nvals)));
+
+		/*
+		 * check that freqs sum to <= 1.0 or some number slightly higer to
+		 * allow for compounded rounding errors.
+		 */
+
+
+		if (nfreqs >= 1)
+		{
+			const float4 freqsummax = 1.1;
+
+			float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+			float4		freqsum = prev;
+
+			for (int i = 1; i < nfreqs; i++)
+			{
+				float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+				if (f > prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in descending "
+									"order, but %f > %f",
+									freqsname, f, prev)));
+
+				freqsum += f;
+				prev = f;
+			}
+
+			if (freqsum > freqsummax)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("The sum of elements in %s must not exceed "
+								"%.2f but is %f",
+								freqsname, freqsummax, freqsum)));
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(eqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = freqs;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = vals;
+
+		k++;
+	}
+
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		const char *statname = param_names[P_HIST_BOUNDS];
+		Datum		strvalue = PG_GETARG_DATUM(P_HIST_BOUNDS);
+		Datum		stavalues = cast_stavalue(&finfo, strvalue, basetypid, typmod);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+		SortSupportData ssupd;
+
+		int			nelems = value_not_null_array_len(arr, statname);
+
+
+
+		memset(&ssupd, 0, sizeof(ssupd));
+		ssupd.ssup_cxt = CurrentMemoryContext;
+		ssupd.ssup_collation = typcoll;
+		ssupd.ssup_nulls_first = false;
+		ssupd.abbreviate = false;
+
+		PrepareSortSupportFromOrderingOp(baseltopr, &ssupd);
+
+		/*
+		 * This is a histogram, which means that the values must be in
+		 * monotonically non-decreasing order. If we every find a case where
+		 * [n] > [n+1], raise an error.
+		 */
+		for (int i = 1; i < nelems; i++)
+		{
+			Datum		a = arr->dvalues[i - 1];
+			Datum		b = arr->dvalues[i];
+
+			if (ssupd.comparator(a, b, &ssupd) > 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s values must be in ascending order %s",
+								statname, TextDatumGetCString(strvalue))));
+
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		const char *statname = param_names[P_CORRELATION];
+		Datum		elem = PG_GETARG_DATUM(P_CORRELATION);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		const float4 corr_min = -1.0;
+		const float4 corr_max = 1.0;
+		float4		corr = PG_GETARG_FLOAT4(P_CORRELATION);
+
+		if ((corr < corr_min) || (corr > corr_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %f is out of range %.1f to %.1f",
+							statname, corr, corr_min, corr_max)));
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(ltopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS && MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if (has_mc_elems)
+	{
+		const char *elemsname = param_names[P_MC_ELEMS];
+		const char *freqsname = param_names[P_MC_ELEM_FREQS];
+		Datum		freqs = PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		Datum		vals = cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+										 basetypid, typmod);
+
+		ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+		ExpandedArrayHeader *valsarr = DatumGetExpandedArray(vals);
+
+		int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+		int			nvals = value_not_null_array_len(valsarr, elemsname);
+
+		/*
+		 * The mcelem freqs array has either 2 or 3 additional values: the min
+		 * frequency, the max frequency, the optional null frequency.
+		 */
+		int			nfreqsmin = nvals + 2;
+		int			nfreqsmax = nvals + 3;
+
+		float4		freqlowbound;
+		float4		freqhighbound;
+
+		if (nfreqs > 0)
+		{
+			if ((nfreqs < nfreqsmin) || (nfreqs > nfreqsmax))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s has %d elements, but must have between "
+								"%d and %d because %s has %d elements",
+								freqsname, nfreqs, nfreqsmin, nfreqsmax,
+								elemsname, nvals)));
+
+			/*
+			 * the freqlowbound and freqhighbound must themselves be valid
+			 * percentages
+			 */
+
+			/* first freq element past the length of the values is the min */
+			freqlowbound = DatumGetFloat4(freqsarr->dvalues[nvals]);
+			if ((freqlowbound < frac_min) || (freqlowbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of "
+								"range %.1f to %.1f",
+								freqsname, "minimum", freqlowbound,
+								frac_min, frac_max)));
+
+			/* second freq element past the length of the values is the max */
+			freqhighbound = DatumGetFloat4(freqsarr->dvalues[nvals + 1]);
+			if ((freqhighbound < frac_min) || (freqhighbound > frac_max))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s %s frequency %f is out of "
+								"range %.1f to %.1f",
+								freqsname, "maximum", freqhighbound,
+								frac_min, frac_max)));
+
+			/* low bound must be < high bound */
+			if (freqlowbound > freqhighbound)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s frequency low bound %f cannot be greater "
+								"than high bound %f",
+								freqsname, freqlowbound, freqhighbound)));
+
+			/*
+			 * third freq element past the length of the values is the null
+			 * frac
+			 */
+			if (nfreqs == nvals + 3)
+			{
+				float4		freqnullpct;
+
+				freqnullpct = DatumGetFloat4(freqsarr->dvalues[nvals + 2]);
+
+				if ((freqnullpct < frac_min) || (freqnullpct > frac_max))
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s %s frequency %f is out of "
+									"range %.1f to %.1f",
+									freqsname, "null", freqnullpct,
+									frac_min, frac_max)));
+			}
+
+			/*
+			 * All the freqs that match up to a val must bet between low/high
+			 * bounds (which is never less strict than frac_min/frac_max) and
+			 * must be in monotonically non-increasing order.
+			 *
+			 * Also, these frequencies do not sum to a number <= 1.0 as is the
+			 * case with MC_FREQS.
+			 */
+			if (nvals > 1)
+			{
+				float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+
+				for (int i = 1; i < nvals; i++)
+				{
+					float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+					if ((f < freqlowbound) || (f > freqhighbound))
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("%s frequency %f is out of range "
+										"%f to %f",
+										freqsname, f,
+										freqlowbound, freqhighbound)));
+					if (f > prev)
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+								 errmsg("%s array values must be in "
+										"descending order, but %f > %f",
+										freqsname, f, prev)));
+
+					prev = f;
+				}
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] =
+			PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] =
+			cast_stavalue(&finfo, PG_GETARG_DATUM(P_MC_ELEMS),
+						  basetypid, typmod);
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		const char *statname = param_names[P_ELEM_COUNT_HIST];
+		Datum		stanumbers = PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stanumbers);
+
+		const float4 last_min = 0.0;
+
+		int			nelems = value_not_null_array_len(arr, statname);
+		float4		last;
+
+		/* Last element must be >= 0 */
+		last = DatumGetFloat4(arr->dvalues[nelems - 1]);
+		if (last < last_min)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s has last element %f < %.1f",
+							statname, last, last_min)));
+
+		/* all other elements must be monotonically nondecreasing */
+		if (nelems > 1)
+		{
+			float4		prev = DatumGetFloat4(arr->dvalues[0]);
+
+			for (int i = 1; i < nelems - 1; i++)
+			{
+				float4		f = DatumGetFloat4(arr->dvalues[i]);
+
+				if (f < prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in ascending "
+									"order, but %f > %f",
+									statname, prev, f)));
+
+				prev = f;
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(baseeqopr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * RANGE_BOUNDS_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM even though
+	 * it is numerically greater, and all other stakinds appear in numerical
+	 * order. We duplicate this quirk to make before/after tests of
+	 * pg_statistic records easier.
+	 *
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+		const char *statname = param_names[P_RANGE_BOUNDS_HIST];
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST);
+		Datum		stavalues = cast_stavalue(&finfo, strvalue, typid, typmod);
+
+		ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+
+		int			nelems = value_not_null_array_len(arr, statname);
+
+		/*
+		 * The values in this array are range types, but in fact it's using
+		 * range types to have two parallel arrays with inclusive/exclusive
+		 * bounds, and those two arrays must each be monotonically
+		 * nondecreasing. So basically we want to test that: lower_bound(N) <=
+		 * lower_bound(N+1) and upper_bound(N) <= upper_bound(N+1)
+		 */
+		if (nelems > 1)
+		{
+			RangeType  *prevrange = DatumGetRangeTypeP(arr->dvalues[0]);
+			RangeBound	prevlower;
+			RangeBound	prevupper;
+			bool		empty;
+
+			range_deserialize(typcache, prevrange, &prevlower,
+							  &prevupper, &empty);
+
+
+			for (int i = 1; i < nelems; i++)
+			{
+				RangeType  *range = DatumGetRangeTypeP(arr->dvalues[i]);
+				RangeBound	lower;
+				RangeBound	upper;
+
+				range_deserialize(typcache, range, &lower, &upper, &empty);
+
+				if (range_cmp_bounds(typcache, &prevlower, &lower) == 1)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array %s bounds must be in ascending order",
+									statname, "lower")));
+
+				if (range_cmp_bounds(typcache, &prevupper, &upper) == 1)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array %s bounds must be in ascending order",
+									statname, "upper")));
+
+				memcpy(&lower, &prevlower, sizeof(RangeBound));
+				memcpy(&upper, &prevupper, sizeof(RangeBound));
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/*
+	 * P_RANGE_LENGTH_HIST && P_RANGE_EMPTY_FRAC =>
+	 * STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM
+	 */
+	if (has_rl_hist)
+	{
+		const char *histname = param_names[P_RANGE_LENGTH_HIST];
+		const char *fracname = param_names[P_RANGE_EMPTY_FRAC];
+		Datum		elem = PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC);
+		Datum		rlhist = PG_GETARG_DATUM(P_RANGE_LENGTH_HIST);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+		float4		frac = DatumGetFloat4(elem);
+		Datum		stavalue;
+
+		ExpandedArrayHeader *arr;
+		int			nelems;
+
+		if ((frac < frac_min) || (frac > frac_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %f is out of range %.1f to %.1f",
+							fracname, frac, frac_min, frac_max)));
+
+		/*
+		 * RANGE_LENGTH_HIST is stored in an anyarray, but it is known to be
+		 * of type float8[]. It is also a histogram, so it must be in
+		 * monotonically nondecreasing order.
+		 */
+		stavalue = cast_stavalue(&finfo, rlhist, FLOAT8OID, typmod);
+
+		arr = DatumGetExpandedArray(stavalue);
+		nelems = value_not_null_array_len(arr, histname);
+
+		if (nelems > 1)
+		{
+			float8		prev = DatumGetFloat8(arr->dvalues[0]);
+
+			for (int i = 1; i < nelems; i++)
+			{
+				float8		f = DatumGetFloat8(arr->dvalues[i]);
+
+				if (f < prev)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array values must be in ascending "
+									"order, but %f > %f",
+									histname, prev, f)));
+
+				prev = f;
+			}
+		}
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalue;
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for (; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 ObjectIdGetDatum(relid),
+							 Int16GetDatum(attr->attnum),
+							 PG_GETARG_DATUM(P_INHERITED));
+
+	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	indstate = CatalogOpenIndexes(sd);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic];
+
+		for (int i = 0; i < Natts_pg_statistic; i++)
+			replaces[i] = true;
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+	relation_close(rel, NoLock);
+	ReleaseSysCache(atup);
+	PG_RETURN_VOID();
+}
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 0d26e5b422a..fdb138357e3 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12180,4 +12180,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716d..1dddf96576e 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 00000000000..32b9e7ca113
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,939 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ 
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+ERROR:  relpages cannot be NULL
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  could not open relation with OID 0
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  relation cannot be NULL
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  attname cannot be NULL
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  inherited cannot be NULL
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  Relation test is not partitioned, cannot accept inherited stats
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+ERROR:  n_distinct cannot be NULL
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 |                  |                   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac -0.100000 is out of range 0.0 to 1.0
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac 1.100000 is out of range 0.0 to 1.0
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width -1 must be >= 0
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+ERROR:  n_distinct -1.100000 must be >= -1.0
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_vals cannot be NULL when most_common_freqs is NOT NULL
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+ERROR:  most_common_freqs cannot be NULL when most_common_vals is NOT NULL
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+ERROR:  most_common_freqs has 2 elements, but most_common_vals has 3 elements, but they must be equal
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+ERROR:  The sum of elements in most_common_freqs must not exceed 1.10 but is 1.400000
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 | {2,1,3}          | {0.3,0.25,0.05}   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+ERROR:  histogram_bounds array cannot contain NULL values
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+ERROR:  histogram_bounds values must be in ascending order {1,20,3,4}
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   | {1,2,3,4}        |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+ERROR:  correlation -1.100000 is out of range -1.0 to 1.0
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+ERROR:  correlation 1.100000 is out of range -1.0 to 1.0
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type most_common_elems
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+ERROR:  most_common_elem_freqs cannot be NULL when most_common_elems is NOT NULL
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_elems cannot be NULL when most_common_elem_freqs is NOT NULL
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+ERROR:  most_common_elem_freqs has 2 elements, but must have between 4 and 5 because most_common_elems has 2 elements
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.100000 is out of range 0.200000 to 0.300000
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency low bound 0.400000 cannot be greater than high bound 0.300000
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+ERROR:  most_common_elem_freqs null frequency -0.000100 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency -0.150000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency 1.500000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency -0.300000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency 3.000000 is out of range 0.0 to 1.0
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.400000 is out of range 0.200000 to 0.300000
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             | {three,one}       | {0.3,0.2,0.2,0.3,0}    |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type elem_count_histogram
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array cannot contain NULL values
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array values must be in ascending order, but 1.000000 > 0.000000
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_length_histogram
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac cannot be NULL when range_length_histogram is NOT NULL
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+ERROR:  range_length_histogram cannot be NULL when range_empty_frac is NOT NULL
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac -0.500000 is out of range 0.0 to 1.0
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac 1.500000 is out of range 0.0 to 1.0
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+ERROR:  range_length_histogram array values must be in ascending order, but Infinity > 499.000000
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      | {399,499,Infinity}     |              0.5 | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_bounds_histogram
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array lower bounds must be in ascending order
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array upper bounds must be in ascending order
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac |        range_bounds_histogram        
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+--------------------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      |                        |                  | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  imported statistics must have a maximum of 5 slots but 6 given
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 5ac6e871f54..a7a4dfd411c 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -28,7 +28,8 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
 # geometry depends on point, lseg, line, box, path, polygon, circle
 # horology depends on date, time, timetz, timestamp, timestamptz, interval
 # ----------
-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
+test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc stats_export_import
+
 
 # ----------
 # Load huge amounts of data
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 00000000000..b3f17373d3e
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,834 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited true on nonpartitioned table
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => true::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+
+-- error mcelem freq must be non-increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
+    );
+
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
-- 
2.44.0

From adf40a833c14f3f80c7b3f40b5450e494cfb1561 Mon Sep 17 00:00:00 2001
From: Tomas Vondra <tomas@2ndquadrant.com>
Date: Mon, 25 Mar 2024 17:18:34 +0100
Subject: [PATCH 2/4] review

---
 src/backend/statistics/statistics.c               | 11 +++++++++++
 src/test/regress/expected/stats_export_import.out |  4 ++--
 src/test/regress/sql/stats_export_import.sql      |  4 ++--
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
index 3987425ea4d..d1cd8342047 100644
--- a/src/backend/statistics/statistics.c
+++ b/src/backend/statistics/statistics.c
@@ -259,10 +259,16 @@ value_not_null_array_len(ExpandedArrayHeader *arr, const char *name)
  * values, which is a valid input string for an array of the type or basetype
  * of the attribute. Any error generated by the array_in() function will in
  * turn fail the function.
+ *
+ * XXX this is a very looooong function, maybe split that into smaller parts
+ * that do different parts (e.g. checks vs. actual update).
  */
 Datum
 pg_set_attribute_stats(PG_FUNCTION_ARGS)
 {
+	/* XXX this would really deserve some comment that the order matters,
+	 * and so on. It took me ages to realize it's also the index of the
+	 * attribute in function arguments. */
 	enum
 	{
 		P_RELATION = 0,			/* oid */
@@ -285,6 +291,7 @@ pg_set_attribute_stats(PG_FUNCTION_ARGS)
 	};
 
 	/* names of columns that cannot be null */
+	/* XXX surely many of those can be NULL? say, MCV or elem fields */
 	const char *param_names[] = {
 		"relation",
 		"attname",
@@ -352,6 +359,8 @@ pg_set_attribute_stats(PG_FUNCTION_ARGS)
 
 	/*
 	 * A null in a required parameter is an error.
+	 *
+	 * XXX How do we know P_N_DISTINCT is the last non-null argument?
 	 */
 	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
 		if (PG_ARGISNULL(i))
@@ -372,6 +381,8 @@ pg_set_attribute_stats(PG_FUNCTION_ARGS)
 	/*
 	 * If a caller specifies more stakind-stats than we have slots to store
 	 * them, raise an error.
+	 *
+	 * XXX is it a good idea to treat bool as 0/1 int?
 	 */
 	stakind_count = (int) has_mcv + (int) has_mc_elems + (int) has_rl_hist +
 		(int) !PG_ARGISNULL(P_HIST_BOUNDS) +
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
index 32b9e7ca113..c4072fa05f5 100644
--- a/src/test/regress/expected/stats_export_import.out
+++ b/src/test/regress/expected/stats_export_import.out
@@ -339,7 +339,7 @@ AND attname = 'id';
  stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
 (1 row)
 
--- error: scalars can't have mcelem 
+-- error: scalars can't have mcelem
 SELECT pg_catalog.pg_set_attribute_stats(
     relation => 'stats_export_import.test'::regclass,
     attname => 'id'::name,
@@ -483,7 +483,7 @@ SELECT pg_catalog.pg_set_attribute_stats(
     most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
     );
 ERROR:  most_common_elem_freqs frequency 0.400000 is out of range 0.200000 to 0.300000
--- ok: mcelem 
+-- ok: mcelem
 SELECT pg_catalog.pg_set_attribute_stats(
     relation => 'stats_export_import.test'::regclass,
     attname => 'tags'::name,
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
index b3f17373d3e..ef4e74900b3 100644
--- a/src/test/regress/sql/stats_export_import.sql
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -293,7 +293,7 @@ AND tablename = 'test'
 AND inherited = false
 AND attname = 'id';
 
--- error: scalars can't have mcelem 
+-- error: scalars can't have mcelem
 SELECT pg_catalog.pg_set_attribute_stats(
     relation => 'stats_export_import.test'::regclass,
     attname => 'id'::name,
@@ -437,7 +437,7 @@ SELECT pg_catalog.pg_set_attribute_stats(
     most_common_elem_freqs => '{0.3,0.4,0.2,0.3,0.0}'::real[]
     );
 
--- ok: mcelem 
+-- ok: mcelem
 SELECT pg_catalog.pg_set_attribute_stats(
     relation => 'stats_export_import.test'::regclass,
     attname => 'tags'::name,
-- 
2.44.0

From 394e28f8fe7f83e2c0ac6922b67f9df57bd7eb08 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH 3/4] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 100 ++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 src/fe_utils/Makefile                |   1 +
 src/fe_utils/meson.build             |   1 +
 src/fe_utils/stats_export.c          | 201 +++++++++++++++++++++++++++
 src/include/fe_utils/stats_export.h  |  36 +++++
 10 files changed, 353 insertions(+), 2 deletions(-)
 create mode 100644 src/fe_utils/stats_export.c
 create mode 100644 src/include/fe_utils/stats_export.h

diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017ef..1db5cf52eb8 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b8..d5f61399d91 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index b1c4c3ec7f0..621bfa12337 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -59,6 +59,7 @@
 #include "compress_io.h"
 #include "dumputils.h"
 #include "fe_utils/option_utils.h"
+#include "fe_utils/stats_export.h"
 #include "fe_utils/string_utils.h"
 #include "filter.h"
 #include "getopt_long.h"
@@ -428,6 +429,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1146,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7004,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7502,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10252,82 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	const char *stmtname = "relstats";
+	static bool prepared = false;
+	const char *values[2];
+	PGconn     *conn;
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	conn = GetConnection(fout);
+
+	if (!prepared)
+	{
+		int		ver = PQserverVersion(conn);
+		char   *sql = exportRelationStatsSQL(ver);
+
+		if (sql == NULL)
+			pg_fatal("could not prepare stats export query for server version %d",
+					 ver);
+
+		res = PQprepare(conn, stmtname, sql, 2, NULL);
+		if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+			pg_fatal("prepared statement failed: %s",
+					 PQerrorMessage(conn));
+
+		free(sql);
+		prepared = true;
+	}
+
+	values[0] = fmtQualifiedId(dobj->namespace->dobj.name, dobj->name);
+	values[1] = NULL;
+	res = PQexecPrepared(conn, stmtname, 2, values, NULL, NULL, 0);
+
+
+	/* Result set must be 1x1 */
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
+
+	if (PQntuples(res) != 1)
+		pg_fatal("statistics extraction expected one row, but got %d rows", 
+				 PQntuples(res));
+
+	query = createPQExpBuffer();
+	appendPQExpBufferStr(query, strdup(PQgetvalue(res, 0, 0)));
+	appendPQExpBufferStr(query, ";\n");
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATS IMPORT",
+							  .section = SECTION_POST_DATA,
+							  .createStmt = query->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	PQclear(res);
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16681,6 +16762,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind == RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16882,6 +16970,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16994,14 +17083,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+							 indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b45..d6a071ec28f 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b36..69652aa2059 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1d..2d326dec727 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
diff --git a/src/fe_utils/Makefile b/src/fe_utils/Makefile
index 946c05258f0..c734f9f6d3a 100644
--- a/src/fe_utils/Makefile
+++ b/src/fe_utils/Makefile
@@ -32,6 +32,7 @@ OBJS = \
 	query_utils.o \
 	recovery_gen.o \
 	simple_list.o \
+	stats_export.o \
 	string_utils.o
 
 ifeq ($(PORTNAME), win32)
diff --git a/src/fe_utils/meson.build b/src/fe_utils/meson.build
index 14d0482a2cc..fce503f6410 100644
--- a/src/fe_utils/meson.build
+++ b/src/fe_utils/meson.build
@@ -12,6 +12,7 @@ fe_utils_sources = files(
   'query_utils.c',
   'recovery_gen.c',
   'simple_list.c',
+  'stats_export.c',
   'string_utils.c',
 )
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
new file mode 100644
index 00000000000..fd09e6ea8af
--- /dev/null
+++ b/src/fe_utils/stats_export.c
@@ -0,0 +1,201 @@
+/*-------------------------------------------------------------------------
+ *
+ * Utility functions for extracting object statistics for frontend code
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/fe_utils/stats_export.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include "fe_utils/stats_export.h"
+/*
+#include "libpq/libpq-fs.h"
+*/
+#include "fe_utils/string_utils.h"
+
+/*
+ * No-frills catalog queries that are named according to the statistics they
+ * fetch (relation, attribute, extended) and the earliest server version for
+ * which they work. These are presented so that if other use cases arise they
+ * can share the same base queries but utilize them in their own way.
+ *
+ * The queries themselves do not filter results, so it is up to the caller
+ * to append a WHERE clause filtering either on either c.oid or a combination
+ * of c.relname and n.nspname.
+ */
+
+const char *export_class_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, c.relpages, c.reltuples, c.relallvisible "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace";
+
+const char *export_attribute_stats_query_v17 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"s.range_length_histogram::text AS range_length_histogram, "
+	"s.range_empty_frac, "
+	"s.range_bounds_histogram::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+const char *export_attribute_stats_query_v9_2 =
+	"SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname, s.inherited, "
+	"s.null_frac, s.avg_width, s.n_distinct, "
+	"s.most_common_vals::text AS most_common_vals, s.most_common_freqs, "
+	"s.histogram_bounds::text AS histogram_bounds, s.correlation, "
+	"s.most_common_elems::text AS most_common_elems, "
+	"s.most_common_elem_freqs, s.elem_count_histogram, "
+	"NULL::text AS range_length_histogram, NULL::real AS range_empty_frac, "
+	"NULL::text AS range_bounds_histogram "
+	"FROM pg_class AS c "
+	"JOIN pg_namespace AS n ON n.oid = c.relnamespace "
+	"JOIN pg_attribute AS a ON a.attrelid = c.oid AND not a.attisdropped "
+	"JOIN pg_stats AS s ON s.schemaname = n.nspname AND s.tablename = c.relname";
+
+/*
+ * Returns true if the server version number supports exporting regular
+ * (e.g. pg_statistic) statistics.
+ */
+bool
+exportStatsSupported(int server_version_num)
+{
+	return (server_version_num >= MIN_SERVER_NUM);
+}
+
+/*
+ * Returns true if the server version number supports exporting extended
+ * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
+ *
+ * Currently, none do.
+ */
+bool
+exportExtStatsSupported(int server_version_num)
+{
+	return false;
+}
+
+/*
+ * Return the query appropriate for extracting relation statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportClassStatsSQL(int server_version_num)
+{
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_class_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Return the query appropriate for extracting attribute statistics for the
+ * given server version, if one exists.
+ */
+const char *
+exportAttributeStatsSQL(int server_version_num)
+{
+	if (server_version_num >= 170000)
+		return export_attribute_stats_query_v17;
+	if (server_version_num >= MIN_SERVER_NUM)
+		return export_attribute_stats_query_v9_2;
+	return NULL;
+}
+
+/*
+ * Generate a SQL statement that will itself generate a SQL statement to
+ * import all regular stats from a given relation into another relation.
+ *
+ * The query generated takes two parameters.
+ *
+ * $1 is of type Oid, and represents the oid of the source relation.
+ *
+ * $2 is is a cstring, and represents the qualified name of the destination
+ * relation. If NULL, then the qualified name of the source relation will
+ * be used. In either case, the value is casted via ::regclass.
+ *
+ * The function will return NULL for invalid server version numbers.
+ * Otherwise,
+ *
+ * This function needs to work on databases back to 9.2.
+ * The format() function was introduced in 9.1.
+ * The string_agg() aggregate was introduced in 9.0.
+ *
+ */
+char *exportRelationStatsSQL(int server_version_num)
+{
+	const char *relsql = exportClassStatsSQL(server_version_num);
+	const char *attrsql = exportAttributeStatsSQL(server_version_num);
+	const char *filter = "WHERE c.oid = $1::regclass";
+	char	   *s;
+	PQExpBuffer sql;
+
+	if ((relsql == NULL) || (attrsql == NULL))
+		return NULL;
+
+	/*
+	 * Set up the initial CTEs each with the same oid filter
+	 */
+	sql = createPQExpBuffer();
+	appendPQExpBuffer(sql,
+					  "WITH r AS (%s %s), a AS (%s %s), ",
+					  relsql, filter, attrsql, filter);
+
+	/*
+	 * Generate the pg_set_relation_stats function call for the relation
+	 * and one pg_set_attribute_stats function call for each attribute with
+	 * a pg_statistic entry. Give each row an order value such that the
+	 * set relation stats call will be first, followed by the set attribute
+	 * stats calls in attnum order (even though the attributes are identified
+	 * by attname).
+	 *
+	 * Then aggregate the function calls into a single SELECT statement that
+	 * puts the calls in the order described above.
+	 */
+	appendPQExpBufferStr(sql,
+		"s(ord,sql) AS ( "
+			"SELECT 0, format('pg_catalog.pg_set_relation_stats("
+			"%L::regclass, %L::integer, %L::real, %L::integer)', "
+			"coalesce($2, format('%I.%I', r.nspname, r.relname)), "
+			"r.relpages, r.reltuples, r.relallvisible) "
+			"FROM r "
+			"UNION ALL "
+			"SELECT 1, format('pg_catalog.pg_set_attribute_stats( "
+			"relation => %L::regclass, attname => %L::name, "
+			"inherited => %L::boolean, null_frac => %L::real, "
+			"avg_width => %L::integer, n_distinct => %L::real, "
+			"most_common_vals => %L::text, "
+			"most_common_freqs => %L::real[], "
+			"histogram_bounds => %L::text, "
+			"correlation => %L::real, "
+			"most_common_elems => %L::text, "
+			"most_common_elem_freqs => %L::real[], "
+			"elem_count_histogram => %L::real[], "
+			"range_length_histogram => %L::text, "
+			"range_empty_frac => %L::real, "
+			"range_bounds_histogram => %L::text)', "
+			"coalesce($2, format('%I.%I', a.nspname, a.relname)), "
+			"a.attname, a.inherited, a.null_frac, a.avg_width, "
+			"a.n_distinct, a.most_common_vals, a.most_common_freqs, "
+			"a.histogram_bounds, a.correlation, "
+			"a.most_common_elems, a.most_common_elem_freqs, "
+			"a.elem_count_histogram, a.range_length_histogram, "
+			"a.range_empty_frac, a.range_bounds_histogram ) "
+			"FROM a "
+		") "
+		"SELECT 'SELECT ' || string_agg(s.sql, ', ' ORDER BY s.ord) "
+		"FROM s ");
+
+	s = strdup(sql->data);
+	destroyPQExpBuffer(sql);
+	return s;
+}
diff --git a/src/include/fe_utils/stats_export.h b/src/include/fe_utils/stats_export.h
new file mode 100644
index 00000000000..f0dc7041f79
--- /dev/null
+++ b/src/include/fe_utils/stats_export.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * stats_export.h
+ *    Queries to export statistics from current and past versions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/varatt.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STATS_EXPORT_H
+#define STATS_EXPORT_H
+
+#include "postgres_fe.h"
+#include "libpq-fe.h"
+
+/*
+ * The minimum supported version number. No attempt is made to get statistics
+ * import to work on versions older than this. This version was initially chosen
+ * because that was the minimum version supported by pg_dump at the time.
+ */
+#define MIN_SERVER_NUM 90200
+
+extern bool exportStatsSupported(int server_version_num);
+extern bool exportExtStatsSupported(int server_version_num);
+
+extern const char *exportClassStatsSQL(int server_verson_num);
+extern const char *exportAttributeStatsSQL(int server_verson_num);
+
+extern char *exportRelationStatsSQL(int server_version_num);
+
+#endif
-- 
2.44.0

From 567edfd8b77272af9d4320ecf7274cff26343bca Mon Sep 17 00:00:00 2001
From: Tomas Vondra <tv@fuzzy.cz>
Date: Mon, 25 Mar 2024 22:06:49 +0100
Subject: [PATCH 4/4] review

---
 src/bin/pg_dump/pg_dump.c   | 5 ++++-
 src/fe_utils/stats_export.c | 3 +++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 621bfa12337..6e772264509 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -10303,7 +10303,7 @@ dumpRelationStats(Archive *fout, const DumpableObject *dobj,
 		pg_fatal("error in statistics extraction: %s", PQerrorMessage(conn));
 
 	if (PQntuples(res) != 1)
-		pg_fatal("statistics extraction expected one row, but got %d rows", 
+		pg_fatal("statistics extraction expected one row, but got %d rows",
 				 PQntuples(res));
 
 	query = createPQExpBuffer();
@@ -16764,6 +16764,8 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 
 	/* Statistics are dependent on the definition, not the data */
 	/* Views don't have stats */
+	/* XXX is this check needed? we'd find there's no stats, no? */
+	/* XXX the condition is wrong, though */
 	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
 		(tbinfo->relkind == RELKIND_VIEW))
 		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
@@ -17084,6 +17086,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	}
 
 	/* Comments and stats share same .dep */
+	/* XXX what's ".dep"? */
 	dumpid = is_constraint ? indxinfo->indexconstraint :
 							 indxinfo->dobj.dumpId;
 
diff --git a/src/fe_utils/stats_export.c b/src/fe_utils/stats_export.c
index fd09e6ea8af..bcaaf200c24 100644
--- a/src/fe_utils/stats_export.c
+++ b/src/fe_utils/stats_export.c
@@ -78,6 +78,9 @@ exportStatsSupported(int server_version_num)
  * (e.g. pg_statistic_ext, pg_statitic_ext_data) statistics.
  *
  * Currently, none do.
+ *
+ * XXX Why do we even have this? Nothing is using it, even if it called
+ * this function we wouldn't know how to export stats.
  */
 bool
 exportExtStatsSupported(int server_version_num)
-- 
2.44.0

From 7ca575e5a02bf380af92b6144622468a501f7636 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH vjeff] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 229 ++++++++++++++++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 6 files changed, 243 insertions(+), 2 deletions(-)

diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index b1c4c3ec7f..d483122998 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -428,6 +428,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1145,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7003,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7501,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10251,212 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+static const char *rel_stats_arginfo[][2] = {
+	{"relation", "regclass"},
+	{"relpages", "integer"},
+	{"reltuples", "real"},
+	{"relallvisible", "integer"},
+};
+
+static const char *att_stats_arginfo[][2] = {
+	{"relation", "regclass"},
+	{"attname", "name"},
+	{"inherited", "boolean"},
+	{"null_frac", "float4"},
+	{"avg_width", "integer"},
+	{"n_distinct", "float4"},
+	{"most_common_vals", "text"},
+	{"most_common_freqs", "float4[]"},
+	{"histogram_bounds", "text"},
+	{"correlation", "float4"},
+	{"most_common_elems", "text"},
+	{"most_common_elem_freqs", "float4[]"},
+	{"elem_count_histogram", "float4[]"},
+	{"range_length_histogram", "text"},
+	{"range_empty_frac", "float4"},
+	{"range_bounds_histogram", "text"},
+};
+
+
+static void
+getRelStatsExportQuery(PQExpBuffer query, Archive *fout,
+					   const char *schemaname, const char *tablename)
+{
+	resetPQExpBuffer(query);
+	appendPQExpBufferStr(query,
+						 "SELECT oid::regclass as relation, relpages, "
+						 "reltuples, relallvisible "
+						 "FROM pg_class "
+						 "WHERE relnamespace::regnamespace::name = ");
+	appendStringLiteralAH(query, schemaname, fout);
+	appendPQExpBufferStr(query, " AND relname = ");
+	appendStringLiteralAH(query, tablename, fout);
+}
+
+static void
+getAttStatsExportQuery(PQExpBuffer query, Archive *fout,
+					   const char *schemaname, const char *tablename)
+{
+	resetPQExpBuffer(query);
+	appendPQExpBufferStr(query,
+						 "SELECT c.oid::regclass AS relation, "
+						 "s.attname,"
+						 "s.inherited,"
+						 "s.null_frac,"
+						 "s.avg_width,"
+						 "s.n_distinct,"
+						 "s.most_common_vals,"
+						 "s.most_common_freqs,"
+						 "s.histogram_bounds,"
+						 "s.correlation,"
+						 "s.most_common_elems,"
+						 "s.most_common_elem_freqs,"
+						 "s.elem_count_histogram,");
+
+	if (fout->remoteVersion >= 170000)
+		appendPQExpBufferStr(query,
+							 "s.range_length_histogram,"
+							 "s.range_empty_frac,"
+							 "s.range_bounds_histogram ");
+	else
+		appendPQExpBufferStr(query,
+							 "NULL AS range_length_histogram,"
+							 "NULL AS range_empty_frac,"
+							 "NULL AS range_bounds_histogram ");
+
+	appendPQExpBufferStr(query,
+						 "FROM pg_stats s, pg_class c "
+						 "WHERE c.relnamespace::regnamespace::name = s.schemaname "
+						 "AND c.relname = s.tablename "
+						 "AND s.schemaname = ");
+	appendStringLiteralAH(query, schemaname, fout);
+	appendPQExpBufferStr(query, " AND s.tablename = ");
+	appendStringLiteralAH(query, tablename, fout);
+}
+
+static void
+appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname,
+					const char *argval, const char *argtype)
+{
+	appendPQExpBuffer(out, "\t%s => ", argname);
+	appendStringLiteralAH(out, argval, fout);
+	appendPQExpBuffer(out, "::%s", argtype);
+}
+
+static void
+appendRelStatsImport(PQExpBuffer out, Archive *fout, PGresult *res)
+{
+	const char *sep = "";
+
+	if (PQntuples(res) == 0)
+		return;
+
+	if (PQntuples(res) > 1)
+		pg_fatal("relation stats export returned %d rows, expected 1",
+				 PQntuples(res));
+
+	appendPQExpBufferStr(out, "SELECT pg_catalog.pg_set_relation_stats(\n");
+	for (int argno = 0; argno < lengthof(rel_stats_arginfo); argno++)
+	{
+		const char	*argname = rel_stats_arginfo[argno][0];
+		const char	*argtype = rel_stats_arginfo[argno][1];
+		int			 fieldno = PQfnumber(res, argname);
+
+		if (fieldno < 0)
+			pg_fatal("relation stats export query missing field '%s'",
+					 argname);
+
+		if (PQgetisnull(res, 0, fieldno))
+			continue;
+
+		appendPQExpBufferStr(out, sep);
+		appendNamedArgument(out, fout, argname,
+							PQgetvalue(res, 0, fieldno), argtype);
+		sep = ",\n";
+	}
+	appendPQExpBufferStr(out, "\n);\n");
+}
+
+static void
+appendAttStatsImport(PQExpBuffer out, Archive *fout, PGresult *res)
+{
+	for (int rownum = 0; rownum < PQntuples(res); rownum++)
+	{
+		const char *sep = "";
+		appendPQExpBufferStr(out, "SELECT pg_catalog.pg_set_attribute_stats(\n");
+		for (int argno = 0; argno < lengthof(att_stats_arginfo); argno++)
+		{
+			const char	*argname = att_stats_arginfo[argno][0];
+			const char	*argtype = att_stats_arginfo[argno][1];
+			int			 fieldno = PQfnumber(res, argname);
+
+			if (fieldno < 0)
+				pg_fatal("attribute stats export query missing field '%s'",
+						 argname);
+
+			if (PQgetisnull(res, rownum, fieldno))
+				continue;
+
+			appendPQExpBufferStr(out, sep);
+			appendNamedArgument(out, fout, argname,
+								PQgetvalue(res, rownum, fieldno), argtype);
+			sep = ",\n";
+		}
+		appendPQExpBufferStr(out, "\n);\n");
+	}
+}
+
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer out;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename,
+					  fmtId(dobj->name));
+
+	query = createPQExpBuffer();
+	out = createPQExpBuffer();
+
+	getRelStatsExportQuery(query, fout, dobj->namespace->dobj.name,
+						   dobj->name);
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+	appendRelStatsImport(out, fout, res);
+	PQclear(res);
+
+	getAttStatsExportQuery(query, fout, dobj->namespace->dobj.name,
+						   dobj->name);
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+	appendAttStatsImport(out, fout, res);
+	PQclear(res);
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATISTICS DATA",
+							  .section = SECTION_NONE,
+							  .createStmt = out->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(tag);
+	destroyPQExpBuffer(out);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16681,6 +16891,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind != RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16882,6 +17099,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16994,14 +17212,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+		indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b3..69652aa205 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.34.1

From 67509e3d022b4991658ee3b2b8be7ef3544c45a6 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 21 Mar 2024 18:04:54 -0400
Subject: [PATCH v14 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics have to make
sense in the context of the new relation.

The statistics provided will be checked for suitability and consistency,
and will raise an error if found.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the basetype of the attribute, and that
operation may fail if the attribute type has changed. All stakind-based
statistics parameters has a default value of NULL.

In addition, the values provided are checked for consistency where
possible (values in acceptable ranges, array values in sub-ranges
defined within the array itself, array values in order, etc).

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   15 +
 src/include/statistics/statistics.h           |    2 +
 src/backend/catalog/system_functions.sql      |   18 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1283 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  942 ++++++++++++
 src/test/regress/parallel_schedule            |    3 +-
 src/test/regress/sql/stats_export_import.sql  |  836 +++++++++++
 doc/src/sgml/func.sgml                        |  122 ++
 10 files changed, 3223 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 07023ee61d..5dbb291410 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12192,4 +12192,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index fe2bb50f46..22be7e6653 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -636,6 +636,24 @@ LANGUAGE INTERNAL
 CALLED ON NULL INPUT VOLATILE PARALLEL SAFE
 AS 'pg_stat_reset_slru';
 
+CREATE OR REPLACE FUNCTION
+  pg_set_attribute_stats(relation oid, attname name, inherited bool,
+                         null_frac real, avg_width integer, n_distinct real,
+                         most_common_vals text DEFAULT NULL,
+                         most_common_freqs real[] DEFAULT NULL,
+                         histogram_bounds text DEFAULT NULL,
+                         correlation real DEFAULT NULL,
+                         most_common_elems text DEFAULT NULL,
+                         most_common_elem_freqs real[] DEFAULT NULL,
+                         elem_count_histogram real[] DEFAULT NULL,
+                         range_length_histogram text DEFAULT NULL,
+                         range_empty_frac real DEFAULT NULL,
+                         range_bounds_histogram text DEFAULT NULL)
+RETURNS void
+LANGUAGE INTERNAL
+CALLED ON NULL INPUT VOLATILE
+AS 'pg_set_attribute_stats';
+
 --
 -- The default permissions for functions mean that anyone can execute them.
 -- A number of functions shouldn't be executable by just anyone, but rather
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..f0648aea99
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1283 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/rangetypes.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+can_modify_relation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * A more encapsulated version of can_modify_relation for when the the
+ * HeapTuple and Form_pg_class are not needed later.
+ */
+static void
+check_relation_permissions(Relation rel)
+{
+	Oid			relid = RelationGetRelid(rel);
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+
+	/* Test existence of Relation */
+	ctup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!can_modify_relation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+	ReleaseSysCache(ctup);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	/* Convenience enum to simulate naming the function arguments */
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	const char *param_names[] = {
+		"relation",
+		"relpages",
+		"reltuples",
+		"relallvisible"
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* Any NULL parameter is an error */
+	for (int i = P_RELATION; i < P_NUM_PARAMS; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!can_modify_relation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	if (relpages < -1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1", param_names[P_RELPAGES])));
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	if (reltuples < -1.0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1.0", param_names[P_RELTUPLES])));
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+	if (relallvisible < -1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1", param_names[P_RELALLVISIBLE])));
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_VOID();
+}
+
+
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalues(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char	   *s = TextDatumGetCString(d);
+	Datum		out = FunctionCall3(finfo, CStringGetDatum(s),
+									ObjectIdGetDatum(typid),
+									Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+/*
+ * Convenience routine to handle a common pattern where two function
+ * parameters must either both be NULL or both NOT NULL.
+ */
+static bool
+has_arg_pair(FunctionCallInfo fcinfo, const char **pnames, int p1, int p2)
+{
+	/* if on param is NULL and the other NOT NULL, report an error */
+	if (PG_ARGISNULL(p1) != PG_ARGISNULL(p2))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be NULL when %s is NOT NULL",
+						pnames[(PG_ARGISNULL(p1)) ? p1 : p2],
+						pnames[(PG_ARGISNULL(p1)) ? p2 : p1])));
+
+	return (!PG_ARGISNULL(p1));
+}
+
+/*
+ * Test if the type is a scalar for MCELM purposes
+ */
+static bool
+type_is_scalar(Oid typid)
+{
+	HeapTuple	tp;
+	bool		result = false;
+
+	tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
+	if (HeapTupleIsValid(tp))
+	{
+		Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+
+		result = (!OidIsValid(typtup->typanalyze));
+		ReleaseSysCache(tp);
+	}
+	return result;
+}
+
+static int
+value_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	if (arr->ndims != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be a multidimensional array", name)));
+
+	return arr->dims[0];
+}
+
+/*
+ * Convenience routine to encapsulate all of the steps needed for any
+ * value array.
+ */
+static int
+value_not_null_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	const int	nelems = value_array_len(arr, name);
+
+	if (nelems > 0)
+	{
+		deconstruct_expanded_array(arr);
+
+		/* if there's a nulls array, all values must be false */
+		if (arr->dnulls != NULL)
+			for (int i = 0; i < nelems; i++)
+				if (arr->dnulls[i])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array cannot contain NULL values", name)));
+	}
+
+	return nelems;
+}
+
+/*
+ * Fetch datatype information, this is needed to derive the proper staopN
+ * and stacollN values.
+ *
+ * If this relation is an index and that index has expressions in it, and
+ * the attnum specified is known to be an expression, then we must walk
+ * the list attributes up to the specified attnum to get the right
+ * expression.
+ *
+ */
+static TypeCacheEntry *
+get_attr_stat_type(Relation rel, Name attname,
+				   int16 *attnum, int32 *typmod, Oid *typcoll)
+{
+	const int	operator_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR;
+	Oid			relid = RelationGetRelid(rel);
+	Form_pg_attribute attr;
+	HeapTuple	atup;
+	Oid			typid;
+
+	atup = SearchSysCache2(ATTNAME, ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	/* Attribute not found */
+	if (!HeapTupleIsValid(atup))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s has no attname %s",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s attname %s is dropped",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	*attnum = attr->attnum;
+
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		*typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			*typcoll = attr->attcollation;
+		else
+			*typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		*typmod = attr->atttypmod;
+		*typcoll = attr->attcollation;
+	}
+	ReleaseSysCache(atup);
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+	return lookup_type_cache(typid, operator_flags);
+}
+
+
+/*
+ * Find the basetype for the given type.
+ */
+static TypeCacheEntry *
+get_base_typecache(TypeCacheEntry *typ)
+{
+	const int	operator_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR;
+	Oid			basetypid;
+
+	/*
+	 * if it's a range type, swap the subtype for the base type, otherwise get
+	 * the base element type
+	 */
+	if (typ->typtype == TYPTYPE_RANGE)
+		basetypid = get_range_subtype(typ->type_id);
+	else
+		basetypid = get_base_element_type(typ->type_id);
+
+	/* Type is already a base type */
+	if (basetypid == InvalidOid)
+		return typ;
+
+	return lookup_type_cache(basetypid, operator_flags);
+}
+
+/*
+ * The null_frac statistic must be in [0.0,1.0].
+ */
+static void
+validate_null_frac(float4 null_frac, const char *statname)
+{
+	const float4 min = 0.0;
+	const float4 max = 1.0;
+
+	if ((null_frac < min) || (null_frac > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						statname, null_frac, min, max)));
+}
+
+/*
+ * The avg_width statistic must be non-negative.
+ */
+static void
+validate_avg_width(int32 avg_width, const char *statname)
+{
+	const int	min = 0;
+
+	if (avg_width < min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %d must be >= %d", statname, avg_width, min)));
+}
+
+/*
+ * The n_distinct statistic cannot be below -1.0.
+ */
+static void
+validate_n_distinct(float4 n_distinct, const char *statname)
+{
+	const float4 min = -1.0;
+
+	if (n_distinct < min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f must be >= %.1f",
+						statname, n_distinct, min)));
+}
+
+/*
+ * Check correctness of MCV statistics pair.
+ *
+ * The length of the freqs array must be equal to the length of the values
+ * array. Neither array can contain NULL elements.
+ *
+ * The elements in the freqs array must be monotonically nondecreasing, and the
+ * sum of values in the array theoretically should not exceed 1.0, but we use a
+ * more relaxed limit to allow for compounded rounding errors.
+ */
+static void
+validate_mcv(Datum freqs, Datum values, const char *freqsname,
+			 const char *valuesname)
+{
+	ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+	ExpandedArrayHeader *valsarr = DatumGetExpandedArray(values);
+
+	int			nvals = value_array_len(valsarr, valuesname);
+	int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+
+	if (nfreqs != nvals)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has %d elements, but %s has %d elements, "
+						"but they must be equal",
+						freqsname, nfreqs, valuesname, nvals)));
+
+	/*
+	 * check that freqs sum to <= 1.0 or some number slightly higer to allow
+	 * for compounded rounding errors.
+	 */
+	if (nfreqs >= 1)
+	{
+		const float4 freqsummax = 1.1;
+
+		float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+		float4		freqsum = prev;
+
+		for (int i = 1; i < nfreqs; i++)
+		{
+			float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+			if (f > prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in descending "
+								"order, but %f > %f",
+								freqsname, f, prev)));
+
+			freqsum += f;
+			prev = f;
+		}
+
+		if (freqsum > freqsummax)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("The sum of elements in %s must not exceed "
+							"%.2f but is %f",
+							freqsname, freqsummax, freqsum)));
+	}
+}
+
+/*
+ * Check correctness of Histogram Bounds statistics.
+ *
+ * The array represents a histogram, which means that the values must be in
+ * monotonically non-decreasing order.
+ *
+ * If the attribute datatype in question uses collations then this validation
+ * has the chance to turn up any discrepancies in the source and destination
+ * collations if the datatype uses collations.
+ */
+static void
+validate_histogram_bounds(Datum stavalues, Datum srcstrvalue,
+						  Oid ltopr, Oid typcollation,
+						  const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+	SortSupportData ssupd;
+
+	int			nelems = value_not_null_array_len(arr, statname);
+
+	memset(&ssupd, 0, sizeof(ssupd));
+	ssupd.ssup_cxt = CurrentMemoryContext;
+	ssupd.ssup_collation = typcollation;
+	ssupd.ssup_nulls_first = false;
+	ssupd.abbreviate = false;
+
+	PrepareSortSupportFromOrderingOp(ltopr, &ssupd);
+
+	/*
+	 * Array should be in * monotonically non-decreasing order. If we every
+	 * find a case where [n] > [n+1], raise an error.
+	 */
+	for (int i = 1; i < nelems; i++)
+	{
+		Datum		a = arr->dvalues[i - 1];
+		Datum		b = arr->dvalues[i];
+
+		if (ssupd.comparator(a, b, &ssupd) > 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s values must be in ascending order %s",
+							statname, TextDatumGetCString(srcstrvalue))));
+
+	}
+}
+
+/*
+ * Check correctness of Correlation statistics.
+ *
+ * Correlation must be in [-1.0,1,0].
+ */
+static void
+validate_correlation(float4 corr, const char *statname)
+{
+	const float4 min = -1.0;
+	const float4 max = 1.0;
+
+	if ((corr < min) || (corr > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						statname, corr, min, max)));
+}
+
+/*
+ * Check correctness of Most Common Elements statistics.
+ *
+ * Neither array can contain NULL elements.
+ *
+ * The values array must be in monotonically incresing order. Elements may
+ * not repeat.
+ *
+ * Every element in the values array must have a corresponding element in the
+ * freqs array. The freqs array will have two additional elements, representing
+ * the frequency lower bound (LB) and frequency upper bound UB). The freqs
+ * array may have an optoinal extra value representing the null fraction of
+ * values in the column.
+ *
+ * The null fraction, LB and UB must be between [0.0,1.0].
+ *
+ * The LB must be <= the UB.
+ */
+static void
+validate_most_common_elements(Datum freqs, Datum elements, Datum srcstrvalue,
+							  const char *freqsname, const char *elemsname,
+							  Oid ltopr, Oid typcollation)
+{
+	ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+	ExpandedArrayHeader *elemsarr = DatumGetExpandedArray(elements);
+
+	int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+	int			nelems = value_not_null_array_len(elemsarr, elemsname);
+
+	/*
+	 * The mcelem freqs array has either 2 or 3 additional values: the min
+	 * frequency, the max frequency, the optional null frequency.
+	 */
+	const int	nfreqsmin = nelems + 2;
+	const int	nfreqsmax = nelems + 3;
+
+	/*
+	 * the freqlowbound and freqhighbound must themselves be valid percentages
+	 */
+	const float4 frac_min = 0.0;
+	const float4 frac_max = 1.0;
+
+	float4		freqlowbound;
+	float4		freqhighbound;
+
+	if (nfreqs <= 0)
+		return;
+
+	if ((nfreqs < nfreqsmin) || (nfreqs > nfreqsmax))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has %d elements, but must have between "
+						"%d and %d because %s has %d elements",
+						freqsname, nfreqs, nfreqsmin, nfreqsmax,
+						elemsname, nelems)));
+
+	/* first freq element past the length of the values is the min */
+	freqlowbound = DatumGetFloat4(freqsarr->dvalues[nelems]);
+	if ((freqlowbound < frac_min) || (freqlowbound > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %s frequency %f is out of "
+						"range %.1f to %.1f",
+						freqsname, "minimum", freqlowbound,
+						frac_min, frac_max)));
+
+	/* second freq element past the length of the values is the max */
+	freqhighbound = DatumGetFloat4(freqsarr->dvalues[nelems + 1]);
+	if ((freqhighbound < frac_min) || (freqhighbound > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %s frequency %f is out of "
+						"range %.1f to %.1f",
+						freqsname, "maximum", freqhighbound,
+						frac_min, frac_max)));
+
+	/* low bound must be < high bound */
+	if (freqlowbound > freqhighbound)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s frequency low bound %f cannot be greater "
+						"than high bound %f",
+						freqsname, freqlowbound, freqhighbound)));
+
+	/*
+	 * third freq element past the length of the values is the null frac
+	 */
+	if (nfreqs == nelems + 3)
+	{
+		float4		freqnullpct;
+
+		freqnullpct = DatumGetFloat4(freqsarr->dvalues[nelems + 2]);
+
+		if ((freqnullpct < frac_min) || (freqnullpct > frac_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %s frequency %f is out of "
+							"range %.1f to %.1f",
+							freqsname, "null", freqnullpct,
+							frac_min, frac_max)));
+	}
+
+	/*
+	 * All the freqs that match up to a val must be between low/high bounds
+	 * (which is never less strict than frac_min/frac_max)
+	 *
+	 * Also, these frequencies do not sum to a number <= 1.0 as is the case
+	 * with MC_FREQS.
+	 */
+	for (int i = 0; i < nelems; i++)
+	{
+		float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+		if ((f < freqlowbound) || (f > freqhighbound))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s frequency %f is out of range %f to %f",
+							freqsname, f, freqlowbound, freqhighbound)));
+	}
+
+	/*
+	 * All the elements must be unique and in ascending order.
+	 */
+	if (nelems > 1)
+	{
+		SortSupportData ssupd;
+
+		memset(&ssupd, 0, sizeof(ssupd));
+		ssupd.ssup_cxt = CurrentMemoryContext;
+		ssupd.ssup_collation = typcollation;
+		ssupd.ssup_nulls_first = false;
+		ssupd.abbreviate = false;
+
+		PrepareSortSupportFromOrderingOp(ltopr, &ssupd);
+
+		for (int i = 1; i < nelems; i++)
+		{
+			Datum		a = elemsarr->dvalues[i - 1];
+			Datum		b = elemsarr->dvalues[i];
+
+			if (ssupd.comparator(a, b, &ssupd) >= 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s values must be unqiue and in ascending order %s",
+								elemsname, TextDatumGetCString(srcstrvalue))));
+
+		}
+	}
+}
+
+/*
+ * Check correctness of Distinct Elements Count Histogram statistics.
+ *
+ * All elements must be >= 0.0, and must be in monotonically nonincreasing
+ * order.
+ */
+static void
+validate_distinct_elements_count_histogram(Datum stanumbers,
+										   const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stanumbers);
+
+	const float4 last_min = 0.0;
+
+	int			nelems = value_not_null_array_len(arr, statname);
+	float4		last;
+
+	/* Last element must be >= 0 */
+	last = DatumGetFloat4(arr->dvalues[nelems - 1]);
+	if (last < last_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has last element %f < %.1f",
+						statname, last, last_min)));
+
+	/* all other elements must be monotonically nondecreasing */
+	if (nelems > 1)
+	{
+		float4		prev = DatumGetFloat4(arr->dvalues[0]);
+
+		for (int i = 1; i < nelems - 1; i++)
+		{
+			float4		f = DatumGetFloat4(arr->dvalues[i]);
+
+			if (f < prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in ascending "
+								"order, but %f > %f",
+								statname, prev, f)));
+
+			prev = f;
+		}
+	}
+}
+
+/*
+ * Validate Range Bound Histogram statistic.
+ *
+ * The values in this array are ranges of the same scalar type as the attribute
+ * in question and cannot be empty. However those ranges are being used to
+ * represent two parallel arrays with inclusive/exclusive bounds, representing
+ * the histogram of lower bounds and the histogram of upper bounds. Each of
+ * those two arrays must each be monotonically nondecreasing.
+ */
+
+static void
+validate_bounds_histogram(Datum stavalues, Datum strvalue,
+						  TypeCacheEntry *typcache, const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+
+	int			nelems = value_not_null_array_len(arr, statname);
+	RangeType  *prevrange;
+	RangeBound	prevlower;
+	RangeBound	prevupper;
+	bool		empty;
+
+	if (nelems <= 0)
+		return;
+
+	/* check first element for emptiness */
+	prevrange = DatumGetRangeTypeP(arr->dvalues[0]);
+	range_deserialize(typcache, prevrange, &prevlower,
+					  &prevupper, &empty);
+
+	if (empty)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s array bounds cannot have empty elements",
+						statname)));
+
+	/*
+	 * For element N, verify that: lower_bound(N) <= lower_bound(N+1), and
+	 * upper_bound(N) <= upper_bound(N+1)
+	 */
+	for (int i = 1; i < nelems; i++)
+	{
+		RangeType  *range = DatumGetRangeTypeP(arr->dvalues[i]);
+		RangeBound	lower;
+		RangeBound	upper;
+
+		range_deserialize(typcache, range, &lower, &upper, &empty);
+
+		if (empty)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array bounds cannot have empty elements",
+							statname)));
+
+		if (range_cmp_bounds(typcache, &prevlower, &lower) == 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array %s bounds must be in ascending order",
+							statname, "lower")));
+
+		if (range_cmp_bounds(typcache, &prevupper, &upper) == 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array %s bounds must be in ascending order",
+							statname, "upper")));
+
+		memcpy(&lower, &prevlower, sizeof(RangeBound));
+		memcpy(&upper, &prevupper, sizeof(RangeBound));
+	}
+}
+
+/*
+ * Validate Range Length Histogram statistic pair.
+ *
+ * The empty_frac must be between in [0.0,1.0].
+ *
+ * rlhist is a histogram of float8[], so it must be in monotonically
+ * nondecreasing order.
+ */
+static void
+validate_range_length_histogram(Datum rlhist, float4 empty_frac,
+								const char *histname,
+								const char *fracname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(rlhist);
+
+	int			nelems = value_not_null_array_len(arr, histname);
+
+	const float4 min = 0.0;
+	const float4 max = 1.0;
+
+	if ((empty_frac < min) || (empty_frac > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						fracname, empty_frac, min, max)));
+
+	if (nelems > 1)
+	{
+		float8		prev = DatumGetFloat8(arr->dvalues[0]);
+
+		for (int i = 1; i < nelems; i++)
+		{
+			float8		f = DatumGetFloat8(arr->dvalues[i]);
+
+			if (f < prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in ascending "
+								"order, but %f > %f",
+								histname, prev, f)));
+
+			prev = f;
+		}
+	}
+}
+
+/*
+ * Update the pg_statistic record.
+ */
+static void
+update_pg_statistic(Datum values[], bool nulls[])
+{
+	Relation	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	CatalogIndexState indstate = CatalogOpenIndexes(sd);
+	HeapTuple	oldtup;
+	HeapTuple	stup;
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 values[Anum_pg_statistic_starelid - 1],
+							 values[Anum_pg_statistic_staattnum - 1],
+							 values[Anum_pg_statistic_stainherit - 1]);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic];
+
+		for (int i = 0; i < Natts_pg_statistic; i++)
+			replaces[i] = true;
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * The function takes input parameters that correspond to columns in the view
+ * pg_stats.
+ *
+ * Of those, the columns attname, inherited, null_frac, avg_width, and
+ * n_distinct all correspond to NOT NULL columns in pg_statistic. These
+ * parameters have no default value and passing NULL to them will result
+ * in an error.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will raise an error. Likewise for setting inherited statistics
+ * on a table that is not partitioned.
+ *
+ * The remaining parameters all belong to a specific stakind. Some stakinds
+ * have multiple parameters, and in those cases both parameters must be
+ * NOT NULL or both NULL, otherwise an error will be raised.
+ *
+ * Omitting a parameter or explicitly passing NULL means that that particular
+ * stakind is not associated with the attribute.
+ *
+ * Parameters that are NOT NULL will be inspected for consistency checks,
+ * any of which can raise an error.
+ *
+ * Parameters corresponding to ANYARRAY columns are instead passed in as text
+ * values, which is a valid input string for an array of the type or basetype
+ * of the attribute. Any error generated by the array_in() function will in
+ * turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	/* Convenience enum to simulate naming the function arguments */
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of arguments indexed by above enum */
+	const char *param_names[] = {
+		"relation",
+		"attname",
+		"inherited",
+		"null_frac",
+		"avg_width",
+		"n_distinct",
+		"most_common_vals",
+		"most_common_freqs",
+		"histogram_bounds",
+		"correlation",
+		"most_common_elems",
+		"most_common_elem_freqs",
+		"elem_count_histogram",
+		"range_length_histogram",
+		"range_empty_frac",
+		"range_bounds_histogram"
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+
+	TypeCacheEntry *typcache;
+	TypeCacheEntry *basetypcache;
+
+	int16		attnum;
+	int32		typmod;
+	Oid			typcoll;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	FmgrInfo	finfo;
+
+	bool		has_mcv;
+	bool		has_mc_elems;
+	bool		has_rl_hist;
+	int			stakind_count;
+
+	int			k = 0;
+
+	/*
+	 * A null in a required parameter is an error.
+	 */
+	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	/*
+	 * Check all parameter pairs up front.
+	 */
+	has_mcv = has_arg_pair(fcinfo, param_names,
+						   P_MC_VALS, P_MC_FREQS);
+	has_mc_elems = has_arg_pair(fcinfo, param_names,
+								P_MC_ELEMS, P_MC_ELEM_FREQS);
+	has_rl_hist = has_arg_pair(fcinfo, param_names,
+							   P_RANGE_LENGTH_HIST, P_RANGE_EMPTY_FRAC);
+
+	/*
+	 * If a caller specifies more stakind-stats than we have slots to store
+	 * them, raise an error.
+	 */
+	stakind_count = (int) has_mcv + (int) has_mc_elems + (int) has_rl_hist +
+		(int) !PG_ARGISNULL(P_HIST_BOUNDS) +
+		(int) !PG_ARGISNULL(P_CORRELATION) +
+		(int) !PG_ARGISNULL(P_ELEM_COUNT_HIST) +
+		(int) !PG_ARGISNULL(P_RANGE_BOUNDS_HIST);
+
+	if (stakind_count > STATISTIC_NUM_SLOTS)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("imported statistics must have a maximum of %d slots "
+						"but %d given",
+						STATISTIC_NUM_SLOTS, stakind_count)));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	check_relation_permissions(rel);
+
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	typcache = get_attr_stat_type(rel, attname, &attnum, &typmod, &typcoll);
+
+	basetypcache = get_base_typecache(typcache);
+
+	/* P_HIST_BOUNDS and P_CORRELATION must have a base type < operator */
+	if (basetypcache->lt_opr == InvalidOid)
+		for (int i = P_HIST_BOUNDS; i <= P_CORRELATION; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s cannot "
+								"have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Scalar types can't have P_MC_ELEMS, P_MC_ELEM_FREQS, P_ELEM_COUNT_HIST */
+	if (type_is_scalar(typcache->type_id))
+		for (int i = P_MC_ELEMS; i <= P_ELEM_COUNT_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is a scalar type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Only range types can have P_RANGE_x */
+	if ((typcache->typtype != TYPTYPE_RANGE) &&
+		(typcache->typtype != TYPTYPE_RANGE))
+		for (int i = P_RANGE_LENGTH_HIST; i <= P_RANGE_BOUNDS_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is not a range type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	validate_null_frac(PG_GETARG_FLOAT4(P_NULL_FRAC),
+					   param_names[P_NULL_FRAC]);
+	validate_avg_width(PG_GETARG_INT32(P_AVG_WIDTH),
+					   param_names[P_AVG_WIDTH]);
+	validate_n_distinct(PG_GETARG_FLOAT4(P_N_DISTINCT),
+						param_names[P_N_DISTINCT]);
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS && MC_FREQS => STATISTIC_KIND_MCV */
+	if (has_mcv)
+	{
+		Datum		stanumbers = PG_GETARG_DATUM(P_MC_FREQS);
+		Datum		stavalues = cast_stavalues(&finfo, PG_GETARG_DATUM(P_MC_VALS),
+											   typcache->type_id, typmod);
+
+		validate_mcv(stanumbers, stavalues, param_names[P_MC_FREQS],
+					 param_names[P_MC_VALS]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_HIST_BOUNDS);
+		Datum		stavalues = cast_stavalues(&finfo, strvalue,
+											   typcache->type_id, typmod);
+
+		validate_histogram_bounds(stavalues, strvalue, typcache->lt_opr, typcoll,
+								  param_names[P_HIST_BOUNDS]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->lt_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		Datum		elem = PG_GETARG_DATUM(P_CORRELATION);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+		Datum		stanumbers = PointerGetDatum(arry);
+
+		validate_correlation(DatumGetFloat4(elem), param_names[P_CORRELATION]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->lt_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS && MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if (has_mc_elems)
+	{
+		Datum		srcstrvalue = PG_GETARG_DATUM(P_MC_ELEMS);
+		Datum		stanumbers = PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		Datum		stavalues = cast_stavalues(&finfo, srcstrvalue,
+											   basetypcache->type_id, typmod);
+
+		validate_most_common_elements(stanumbers, stavalues, srcstrvalue,
+									  param_names[P_MC_ELEM_FREQS],
+									  param_names[P_MC_ELEMS],
+									  basetypcache->lt_opr, typcoll);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(basetypcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		Datum		stanumbers = PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+
+		validate_distinct_elements_count_histogram(stanumbers,
+												   param_names[P_ELEM_COUNT_HIST]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(basetypcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * RANGE_BOUNDS_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM even though
+	 * it is numerically greater, and all other stakinds appear in numerical
+	 * order. We duplicate this quirk to make before/after tests of
+	 * pg_statistic records easier.
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST);
+		Datum		stavalues = cast_stavalues(&finfo, strvalue,
+											   typcache->type_id, typmod);
+
+		validate_bounds_histogram(stavalues, strvalue, typcache,
+								  param_names[P_RANGE_BOUNDS_HIST]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/*
+	 * P_RANGE_LENGTH_HIST && P_RANGE_EMPTY_FRAC =>
+	 * STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM
+	 */
+	if (has_rl_hist)
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_LENGTH_HIST);
+
+		/* The anyarray is always a float8[] for this stakind */
+		Datum		stavalues = cast_stavalues(&finfo, strvalue, FLOAT8OID, 0);
+		Datum		elem = PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		validate_range_length_histogram(stavalues,
+										DatumGetFloat4(elem),
+										param_names[P_RANGE_LENGTH_HIST],
+										param_names[P_RANGE_EMPTY_FRAC]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for (; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	update_pg_statistic(values, nulls);
+
+	relation_close(rel, NoLock);
+	PG_RETURN_VOID();
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..482f1eb2a3
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,942 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ 
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+ERROR:  relpages cannot be NULL
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  could not open relation with OID 0
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  relation cannot be NULL
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  attname cannot be NULL
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  inherited cannot be NULL
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+ERROR:  n_distinct cannot be NULL
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 |                  |                   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac -0.100000 is out of range 0.0 to 1.0
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac 1.100000 is out of range 0.0 to 1.0
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width -1 must be >= 0
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+ERROR:  n_distinct -1.100000 must be >= -1.0
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_vals cannot be NULL when most_common_freqs is NOT NULL
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+ERROR:  most_common_freqs cannot be NULL when most_common_vals is NOT NULL
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+ERROR:  most_common_freqs has 2 elements, but most_common_vals has 3 elements, but they must be equal
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+ERROR:  The sum of elements in most_common_freqs must not exceed 1.10 but is 1.400000
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 | {2,1,3}          | {0.3,0.25,0.05}   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+ERROR:  histogram_bounds array cannot contain NULL values
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+ERROR:  histogram_bounds values must be in ascending order {1,20,3,4}
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   | {1,2,3,4}        |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+ERROR:  correlation -1.100000 is out of range -1.0 to 1.0
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+ERROR:  correlation 1.100000 is out of range -1.0 to 1.0
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type most_common_elems
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+ERROR:  most_common_elem_freqs cannot be NULL when most_common_elems is NOT NULL
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_elems cannot be NULL when most_common_elem_freqs is NOT NULL
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+ERROR:  most_common_elem_freqs has 2 elements, but must have between 4 and 5 because most_common_elems has 2 elements
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.100000 is out of range 0.200000 to 0.300000
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency low bound 0.400000 cannot be greater than high bound 0.300000
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+ERROR:  most_common_elem_freqs null frequency -0.000100 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency -0.150000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency 1.500000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency -0.300000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency 3.000000 is out of range 0.0 to 1.0
+-- error mcelem values must be monotonically increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.3,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elems values must be unqiue and in ascending order {three,one}
+-- error mcelem values must be unique
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three,three}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.4,0.2,0.5,0.0}'::real[]
+    );
+ERROR:  most_common_elems values must be unqiue and in ascending order {one,three,three}
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             | {one,three}       | {0.3,0.2,0.2,0.3,0}    |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type elem_count_histogram
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array cannot contain NULL values
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array values must be in ascending order, but 1.000000 > 0.000000
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_length_histogram
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac cannot be NULL when range_length_histogram is NOT NULL
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+ERROR:  range_length_histogram cannot be NULL when range_empty_frac is NOT NULL
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac -0.500000 is out of range 0.0 to 1.0
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac 1.500000 is out of range 0.0 to 1.0
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+ERROR:  range_length_histogram array values must be in ascending order, but Infinity > 499.000000
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      | {399,499,Infinity}     |              0.5 | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_bounds_histogram
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array lower bounds must be in ascending order
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array upper bounds must be in ascending order
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac |        range_bounds_histogram        
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+--------------------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      |                        |                  | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  imported statistics must have a maximum of 5 slots but 6 given
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 5ac6e871f5..a7a4dfd411 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -28,7 +28,8 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
 # geometry depends on point, lseg, line, box, path, polygon, circle
 # horology depends on date, time, timetz, timestamp, timestamptz, interval
 # ----------
-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
+test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc stats_export_import
+
 
 # ----------
 # Load huge amounts of data
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..1a7d02a2c7
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,836 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+
+-- error mcelem values must be monotonically increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.3,0.2,0.3,0.0}'::real[]
+    );
+-- error mcelem values must be unique
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three,three}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.4,0.2,0.5,0.0}'::real[]
+    );
+
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 93b0bc2bc6..153d0dc6ac 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29123,6 +29123,128 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back
+        through normal transaction processing.
+       </para>
+       <para>
+        This function mimics the behavior of <command>ANALYZE</command> in its
+        effects on the values in <structname>pg_class</structname>, except that
+        the values are supplied as parameters rather than derived from table
+        sampling.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       <para>
+        The parameters supplied must all be NOT NULL. The value of
+        <structfield>relpages</structfield> must not be less than 0.  The
+        value of <structfield>reltuples</structfield> must not be less than
+        -1.0.  The value of <structfield>relallvisible</structfield> must not
+        be less than 0.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>
+         , <parameter>attname</parameter> <type>name</type>
+         , <parameter>inherited</parameter> <type>boolean</type>
+         , <parameter>null_frac</parameter> <type>real</type>
+         , <parameter>avg_width</parameter> <type>integer</type>
+         , <parameter>n_distinct</parameter> <type>real</type>
+         [, <parameter>most_common_vals</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>histogram_bounds</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>correlation</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elems</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elem_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>elem_count_histogram</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_length_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_empty_frac</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_bounds_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ] )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>. The remaining parameters
+        all correspond to attributes of the same name found in
+        <link linkend="view-pg-stats"><structname>pg_stats</structname></link>,
+        and the values supplied in the parameter must meet the requirements of
+        the corresponding attribute.
+       </para>
+       <para>
+        This function mimics the behavior of <command>ANALYZE</command> in its
+        effects on the values in <structname>pg_statistic</structname>, except
+        that the values are supplied as parameters rather than derived from
+        table sampling.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From c70f5cb4ef5d5f919036725331ff89a31234d215 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v14 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will also generate a statement
that calls all of the pg_set_relation_stats() and
pg_set_attribute_stats() calls necessary to restore the statistics of
the current system onto the destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/bin/pg_dump/pg_backup.h          |   2 +
 src/bin/pg_dump/pg_backup_archiver.c |   5 +
 src/bin/pg_dump/pg_dump.c            | 326 ++++++++++++++++++++++++++-
 src/bin/pg_dump/pg_dump.h            |   1 +
 src/bin/pg_dump/pg_dumpall.c         |   5 +
 src/bin/pg_dump/pg_restore.c         |   3 +
 6 files changed, 340 insertions(+), 2 deletions(-)

diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index b1c4c3ec7f..29029909e9 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -428,6 +428,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1145,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7003,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7501,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10251,309 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * Convenience routine for constructing parameters of the form:
+ *  paraname => 'value'::type
+ */
+static void
+appendNamedCastedParam(PQExpBuffer str, const char *param, const char *value,
+					   const char *type, Archive *fout)
+{
+	appendPQExpBuffer(str, "%s => ", param);
+	appendStringLiteralAH(str, value, fout);
+	appendPQExpBuffer(str, "::%s", type);
+}
+
+/*
+ * Append a formatted pg_set_relation_stats statement.
+ */
+static void
+appendSetRelationStats(PQExpBuffer str, const char *qualrelname,
+					   PGresult *res, Archive *fout)
+{
+	int			i_relpages = PQfnumber(res, "relpages");
+	int			i_reltuples = PQfnumber(res, "relpages");
+	int			i_relallvisible = PQfnumber(res, "relallvisible");
+	char	   *val;
+
+	if (PQgetisnull(res, 0, i_relpages))
+		pg_fatal("Unexpected NULL found in %s", "relpages");
+	if (PQgetisnull(res, 0, i_reltuples))
+		pg_fatal("Unexpected NULL found in %s", "reltuples");
+	if (PQgetisnull(res, 0, i_relallvisible))
+		pg_fatal("Unexpected NULL found in %s", "relallvisible");
+
+	appendPQExpBufferStr(str, "SELECT pg_catalog.pg_set_relation_stats(\n");
+	appendNamedCastedParam(str, "relation",
+						   qualrelname, "regclass", fout);
+	appendPQExpBufferStr(str, ",\n");
+	val = PQgetvalue(res, 0, i_relpages);
+	appendNamedCastedParam(str, "relpages", val, "integer", fout);
+	appendPQExpBufferStr(str, ",\n");
+	val = PQgetvalue(res, 0, i_reltuples);
+	appendNamedCastedParam(str, "reltuples", val, "real", fout);
+	appendPQExpBufferStr(str, ",\n");
+	val = PQgetvalue(res, 0, i_relallvisible);
+	appendNamedCastedParam(str, "relallvisible", val, "integer", fout);
+	appendPQExpBufferStr(str, ");\n");
+}
+
+/*
+ * Append a series of formatted pg_set_attribute_stats statements.
+ */
+static void
+appendSetAttributeStats(PQExpBuffer str, const char *qualrelname,
+						PGresult *res, Archive *fout)
+{
+	/* these are required */
+	int			i_attname = PQfnumber(res, "attname");
+	int			i_inherited = PQfnumber(res, "inherited");
+	int			i_null_frac = PQfnumber(res, "null_frac");
+	int			i_avg_width = PQfnumber(res, "avg_width");
+	int			i_n_distinct = PQfnumber(res, "n_distinct");
+
+	/* these are optional, can be NULL */
+	int			i_most_common_vals = PQfnumber(res, "most_common_vals");
+	int			i_most_common_freqs = PQfnumber(res, "most_common_freqs");
+	int			i_histogram_bounds = PQfnumber(res, "histogram_bounds");
+	int			i_correlation = PQfnumber(res, "correlation");
+	int			i_most_common_elems = PQfnumber(res, "most_common_elems");
+	int			i_most_common_elem_freqs = PQfnumber(res, "most_common_elem_freqs");
+	int			i_elem_count_histogram = PQfnumber(res, "elem_count_histogram");
+	int			i_range_length_histogram = PQfnumber(res, "range_length_histogram");
+	int			i_range_empty_frac = PQfnumber(res, "range_empty_frac");
+	int			i_range_bounds_histogram = PQfnumber(res, "range_bounds_histogram");
+
+	int			ntups = PQntuples(res);
+
+	for (int i = 0; i < ntups; i++)
+	{
+		char	   *val;
+
+		if (PQgetisnull(res, i, i_attname))
+			pg_fatal("Unexpected NULL found in %s", "attname");
+		if (PQgetisnull(res, i, i_inherited))
+			pg_fatal("Unexpected NULL found in %s", "inherited");
+		if (PQgetisnull(res, i, i_null_frac))
+			pg_fatal("Unexpected NULL found in %s", "null_frac");
+		if (PQgetisnull(res, i, i_avg_width))
+			pg_fatal("Unexpected NULL found in %s", "avg_width");
+		if (PQgetisnull(res, i, i_n_distinct))
+			pg_fatal("Unexpected NULL found in %s", "n_distinct");
+
+		appendPQExpBufferStr(str,
+							 "SELECT pg_catalog.pg_set_attribute_stats(\n");
+		appendNamedCastedParam(str, "relation", qualrelname, "regclass", fout);
+		appendPQExpBufferStr(str, ",\n");
+		val = PQgetvalue(res, i, i_attname);
+		appendNamedCastedParam(str, "attname", val, "name", fout);
+		appendPQExpBufferStr(str, ",\n");
+		val = PQgetvalue(res, i, i_inherited);
+		appendNamedCastedParam(str, "inherited", val, "boolean", fout);
+		appendPQExpBufferStr(str, ",\n");
+		val = PQgetvalue(res, i, i_null_frac);
+		appendNamedCastedParam(str, "null_frac", val, "real", fout);
+		appendPQExpBufferStr(str, ",\n");
+		val = PQgetvalue(res, i, i_avg_width);
+		appendNamedCastedParam(str, "avg_width", val, "integer", fout);
+		appendPQExpBufferStr(str, ",\n");
+		val = PQgetvalue(res, i, i_n_distinct),
+			appendNamedCastedParam(str, "n_distinct", val, "real", fout);
+
+		/* Optional parameters */
+		if (!PQgetisnull(res, i, i_most_common_vals))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_most_common_vals);
+			appendNamedCastedParam(str, "most_common_vals", val, "text", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_most_common_freqs))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_most_common_freqs);
+			appendNamedCastedParam(str, "most_common_freqs", val, "real[]", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_histogram_bounds))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_histogram_bounds);
+			appendNamedCastedParam(str, "histogram_bounds", val, "text", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_correlation))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_correlation);
+			appendNamedCastedParam(str, "correlation", val, "real", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_most_common_elems))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_most_common_elems);
+			appendNamedCastedParam(str, "most_common_elems", val, "text", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_most_common_elem_freqs))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_most_common_elem_freqs);
+			appendNamedCastedParam(str, "most_common_elem_freqs", val, "real[]", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_elem_count_histogram))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_elem_count_histogram);
+			appendNamedCastedParam(str, "elem_count_histogram", val, "real[]", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_range_length_histogram))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_range_length_histogram);
+			appendNamedCastedParam(str, "range_length_histogram", val, "text", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_range_empty_frac))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_range_empty_frac);
+			appendNamedCastedParam(str, "range_empty_frac", val, "real", fout);
+		}
+
+		if (!PQgetisnull(res, i, i_range_bounds_histogram))
+		{
+			appendPQExpBufferStr(str, ",\n");
+			val = PQgetvalue(res, i, i_range_bounds_histogram);
+			appendNamedCastedParam(str, "range_bounds_histogram", val, "text", fout);
+		}
+		appendPQExpBufferStr(str, ");\n");
+	}
+}
+
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	const char *nspname = dobj->namespace->dobj.name;
+	const char *relname = dobj->name;
+
+	static bool prepared = false;
+
+	char	   *qualrelname = pg_strdup(fmtQualifiedId(nspname, relname));
+	PQExpBuffer query = createPQExpBuffer();	/* the extract queries */
+	PQExpBuffer out = createPQExpBuffer();	/* the dumped statements */
+	PGresult   *res;
+	PQExpBuffer tag = createPQExpBuffer();
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	if (!prepared)
+	{
+		ArchiveHandle *AH = (ArchiveHandle *) fout;
+		int			ver = PQserverVersion(AH->connection);
+
+		/* Prepare getRelStats */
+		appendPQExpBufferStr(query,
+							 "PREPARE getRelStats(pg_catalog.oid) AS\n");
+
+		if (ver >= fout->minRemoteVersion)
+			appendPQExpBufferStr(query,
+								 "SELECT c.relpages, c.reltuples, "
+								 "c.relallvisible\n"
+								 "FROM pg_catalog.pg_class AS c\n");
+		else
+			pg_fatal("could not prepare stats export query for "
+					 "server version %d", ver);
+
+		appendPQExpBufferStr(query, "WHERE c.oid = $1");
+
+		ExecuteSqlStatement(fout, query->data);
+
+		resetPQExpBuffer(query);
+
+		/* Prepare getAttrStats */
+		appendPQExpBufferStr(query,
+							 "PREPARE getAttrStats(pg_catalog.oid) AS\n"
+							 "SELECT s.attname, s.inherited, s.null_frac, "
+							 "s.avg_width, s.n_distinct, s.most_common_vals,\n"
+							 "s.most_common_freqs, s.histogram_bounds, "
+							 "s.correlation, s.most_common_elems,\n"
+							 "s.most_common_elem_freqs, "
+							 "s.elem_count_histogram,\n");
+
+		if (ver >= 170000)
+			appendPQExpBufferStr(query,
+								 "s.range_length_histogram, "
+								 "s.range_empty_frac, "
+								 "s.range_bounds_histogram\n");
+		else if (ver >= fout->minRemoteVersion)
+			appendPQExpBufferStr(query,
+								 "NULL::text AS range_length_histogram, "
+								 "NULL::real AS range_empty_frac, "
+								 "NULL::text AS range_bounds_histogram\n");
+		else
+			pg_fatal("could not prepare stats export query for "
+					 "server version %d", ver);
+
+		appendPQExpBuffer(query,
+						  "FROM pg_catalog.pg_class AS c\n"
+						  "JOIN pg_catalog.pg_namespace AS n "
+						  "ON n.oid = c.relnamespace\n"
+						  "JOIN pg_catalog.pg_stats AS s "
+						  "ON s.schemaname = n.nspname "
+						  "AND s.tablename = c.relname\n"
+						  "WHERE c.oid = $1");
+
+		ExecuteSqlStatement(fout, query->data);
+
+		resetPQExpBuffer(query);
+
+		prepared = true;
+	}
+
+	printfPQExpBuffer(query, "EXECUTE getRelStats('%u')", dobj->catId.oid);
+
+	res = ExecuteSqlQueryForSingleRow(fout, query->data);
+
+	appendSetRelationStats(out, qualrelname, res, fout);
+
+	PQclear(res);
+
+	printfPQExpBuffer(query, "EXECUTE getAttrStats('%u')", dobj->catId.oid);
+
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+
+	appendSetAttributeStats(out, qualrelname, res, fout);
+
+	PQclear(res);
+
+	appendPQExpBuffer(tag, "%s %s", reltypename, fmtId(dobj->name));
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATISTICS DATA",
+							  .section = SECTION_NONE,
+							  .createStmt = out->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(out);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16681,6 +16988,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind != RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16882,6 +17196,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16994,14 +17309,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+		indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b3..69652aa205 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
-- 
2.44.0

From 210c45ac73361b33834aed5af2c90f3d53d345e7 Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Thu, 21 Mar 2024 18:04:54 -0400
Subject: [PATCH v15 1/2] Create pg_set_relation_stats, pg_set_attribute_stats.

These functions will be used by pg_dump/restore and pg_upgrade to convey
relation and attribute statistics from the source database to the
target. This would be done instead of vacuumdb --analyze-in-stages.

Both functions take an oid to identify the target relation that will
receive the statistics. There is nothing requiring that relation to be
the same one as the one exported, though the statistics have to make
sense in the context of the new relation.

The statistics provided will be checked for suitability and consistency,
and will raise an error if found.

The parameters of pg_set_attribute_stats intentionaly mirror the columns
in the view pg_stats, with the ANYARRAY types casted to TEXT. Those
values will be cast to arrays of the element type of the attribute, and that
operation may fail if the attribute type has changed. All stakind-based
statistics parameters has a default value of NULL.

In addition, the values provided are checked for consistency where
possible (values in acceptable ranges, array values in sub-ranges
defined within the array itself, array values in order, etc).

The statistics imported by pg_set_attribute_stats are imported
transactionally like any other operation. However, pg_set_relation_stats
does it's update in-place, which is to say non-transactionally. This is
in line with what ANALYZE does to avoid table bloat in pg_class.

These functions also allows for tweaking of table statistics in-place,
allowing the user to inflate rowcounts, skew histograms, etc, to see
what those changes will evoke from the query planner.
---
 src/include/catalog/pg_proc.dat               |   15 +
 src/include/statistics/statistics.h           |    2 +
 src/backend/catalog/system_functions.sql      |   18 +
 src/backend/statistics/Makefile               |    3 +-
 src/backend/statistics/meson.build            |    1 +
 src/backend/statistics/statistics.c           | 1289 +++++++++++++++++
 .../regress/expected/stats_export_import.out  |  942 ++++++++++++
 src/test/regress/parallel_schedule            |    3 +-
 src/test/regress/sql/stats_export_import.sql  |  836 +++++++++++
 doc/src/sgml/func.sgml                        |  122 ++
 10 files changed, 3229 insertions(+), 2 deletions(-)
 create mode 100644 src/backend/statistics/statistics.c
 create mode 100644 src/test/regress/expected/stats_export_import.out
 create mode 100644 src/test/regress/sql/stats_export_import.sql

diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 07023ee61d..5dbb291410 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12192,4 +12192,19 @@
   proargtypes => 'int2',
   prosrc => 'gist_stratnum_identity' },
 
+# Statistics Import
+{ oid => '8048',
+  descr => 'set statistics on relation',
+  proname => 'pg_set_relation_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid int4 float4 int4',
+  proargnames => '{relation,relpages,reltuples,relallvisible}',
+  prosrc => 'pg_set_relation_stats' },
+{ oid => '8049',
+  descr => 'set statistics on attribute',
+  proname => 'pg_set_attribute_stats', provolatile => 'v', proisstrict => 'f',
+  proparallel => 'u', prorettype => 'void',
+  proargtypes => 'oid name bool float4 int4 float4 text _float4 text float4 text _float4 _float4 text float4 text',
+  proargnames => '{relation,attname,inherited,null_frac,avg_width,n_distinct,most_common_vals,most_common_freqs,histogram_bounds,correlation,most_common_elems,most_common_elem_freqs,elem_count_histogram,range_length_histogram,range_empty_frac,range_bounds_histogram}',
+  prosrc => 'pg_set_attribute_stats' },
 ]
diff --git a/src/include/statistics/statistics.h b/src/include/statistics/statistics.h
index 7f2bf18716..1dddf96576 100644
--- a/src/include/statistics/statistics.h
+++ b/src/include/statistics/statistics.h
@@ -127,4 +127,6 @@ extern StatisticExtInfo *choose_best_statistics(List *stats, char requiredkind,
 												int nclauses);
 extern HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx);
 
+extern Datum pg_set_relation_stats(PG_FUNCTION_ARGS);
+extern Datum pg_set_attribute_stats(PG_FUNCTION_ARGS);
 #endif							/* STATISTICS_H */
diff --git a/src/backend/catalog/system_functions.sql b/src/backend/catalog/system_functions.sql
index fe2bb50f46..22be7e6653 100644
--- a/src/backend/catalog/system_functions.sql
+++ b/src/backend/catalog/system_functions.sql
@@ -636,6 +636,24 @@ LANGUAGE INTERNAL
 CALLED ON NULL INPUT VOLATILE PARALLEL SAFE
 AS 'pg_stat_reset_slru';
 
+CREATE OR REPLACE FUNCTION
+  pg_set_attribute_stats(relation oid, attname name, inherited bool,
+                         null_frac real, avg_width integer, n_distinct real,
+                         most_common_vals text DEFAULT NULL,
+                         most_common_freqs real[] DEFAULT NULL,
+                         histogram_bounds text DEFAULT NULL,
+                         correlation real DEFAULT NULL,
+                         most_common_elems text DEFAULT NULL,
+                         most_common_elem_freqs real[] DEFAULT NULL,
+                         elem_count_histogram real[] DEFAULT NULL,
+                         range_length_histogram text DEFAULT NULL,
+                         range_empty_frac real DEFAULT NULL,
+                         range_bounds_histogram text DEFAULT NULL)
+RETURNS void
+LANGUAGE INTERNAL
+CALLED ON NULL INPUT VOLATILE
+AS 'pg_set_attribute_stats';
+
 --
 -- The default permissions for functions mean that anyone can execute them.
 -- A number of functions shouldn't be executable by just anyone, but rather
diff --git a/src/backend/statistics/Makefile b/src/backend/statistics/Makefile
index 89cf8c2797..e4f8ab7c4f 100644
--- a/src/backend/statistics/Makefile
+++ b/src/backend/statistics/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	dependencies.o \
 	extended_stats.o \
 	mcv.o \
-	mvdistinct.o
+	mvdistinct.o \
+	statistics.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/statistics/meson.build b/src/backend/statistics/meson.build
index 73b29a3d50..331e82c776 100644
--- a/src/backend/statistics/meson.build
+++ b/src/backend/statistics/meson.build
@@ -5,4 +5,5 @@ backend_sources += files(
   'extended_stats.c',
   'mcv.c',
   'mvdistinct.c',
+  'statistics.c',
 )
diff --git a/src/backend/statistics/statistics.c b/src/backend/statistics/statistics.c
new file mode 100644
index 0000000000..04868c587f
--- /dev/null
+++ b/src/backend/statistics/statistics.c
@@ -0,0 +1,1289 @@
+/*-------------------------------------------------------------------------
+ * statistics.c
+ *
+ *	  POSTGRES statistics import
+ *
+ * Code supporting the direct importation of relation statistics, similar to
+ * what is done by the ANALYZE command.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *       src/backend/statistics/statistics.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/pg_collation.h"
+#include "catalog/pg_database.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_type.h"
+#include "catalog/indexing.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "statistics/statistics.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/float.h"
+#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
+#include "utils/rangetypes.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ * A role has privileges to vacuum or analyze the relation if any of the
+ * following are true:
+ *   - the role owns the current database and the relation is not shared
+ *   - the role has the MAINTAIN privilege on the relation
+ *
+ */
+static bool
+can_modify_relation(Oid relid, Form_pg_class reltuple)
+{
+	return ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId())
+			 && !reltuple->relisshared) ||
+			pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK);
+}
+
+/*
+ * A more encapsulated version of can_modify_relation for when the the
+ * HeapTuple and Form_pg_class are not needed later.
+ */
+static void
+check_relation_permissions(Relation rel)
+{
+	Oid			relid = RelationGetRelid(rel);
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+
+	/* Test existence of Relation */
+	ctup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+
+	if (!HeapTupleIsValid(ctup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!can_modify_relation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+	ReleaseSysCache(ctup);
+}
+
+/*
+ * Set statistics for a given pg_class entry.
+ *
+ * This does an in-place (i.e. non-transactional) update of pg_class, just as
+ * is done in ANALYZE.
+ *
+ */
+Datum
+pg_set_relation_stats(PG_FUNCTION_ARGS)
+{
+	/* Convenience enum to simulate naming the function arguments */
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_RELPAGES,				/* int */
+		P_RELTUPLES,			/* float4 */
+		P_RELALLVISIBLE,		/* int */
+		P_NUM_PARAMS
+	};
+
+	const char *param_names[] = {
+		"relation",
+		"relpages",
+		"reltuples",
+		"relallvisible"
+	};
+
+	Oid			relid;
+	Relation	rel;
+	HeapTuple	ctup;
+	Form_pg_class pgcform;
+	float4		reltuples;
+	int			relpages;
+	int			relallvisible;
+
+	/* Any NULL parameter is an error */
+	for (int i = P_RELATION; i < P_NUM_PARAMS; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	/*
+	 * Open the relation, getting ShareUpdateExclusiveLock to ensure that no
+	 * other stat-setting operation can run on it concurrently.
+	 */
+	rel = table_open(RelationRelationId, ShareUpdateExclusiveLock);
+
+	ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(ctup))
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_IN_USE),
+				 errmsg("pg_class entry for relid %u not found", relid)));
+
+	pgcform = (Form_pg_class) GETSTRUCT(ctup);
+
+	if (!can_modify_relation(relid, pgcform))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for relation %s",
+						RelationGetRelationName(rel))));
+
+
+	relpages = PG_GETARG_INT32(P_RELPAGES);
+	if (relpages < -1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1", param_names[P_RELPAGES])));
+	reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+	if (reltuples < -1.0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1.0", param_names[P_RELTUPLES])));
+	relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+	if (relallvisible < -1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be < -1", param_names[P_RELALLVISIBLE])));
+
+	/* Only update pg_class if there is a meaningful change */
+	if ((pgcform->reltuples != reltuples)
+		|| (pgcform->relpages != relpages)
+		|| (pgcform->relallvisible != relallvisible))
+	{
+		pgcform->relpages = PG_GETARG_INT32(P_RELPAGES);
+		pgcform->reltuples = PG_GETARG_FLOAT4(P_RELTUPLES);
+		pgcform->relallvisible = PG_GETARG_INT32(P_RELALLVISIBLE);
+
+		heap_inplace_update(rel, ctup);
+	}
+
+	table_close(rel, NoLock);
+
+	PG_RETURN_VOID();
+}
+
+
+
+/*
+ * Perform the cast of text to some array type
+ */
+static Datum
+cast_stavalues(FmgrInfo *finfo, Datum d, Oid typid, int32 typmod)
+{
+	char	   *s = TextDatumGetCString(d);
+	Datum		out = FunctionCall3(finfo, CStringGetDatum(s),
+									ObjectIdGetDatum(typid),
+									Int32GetDatum(typmod));
+
+	pfree(s);
+
+	return out;
+}
+
+/*
+ * Convenience routine to handle a common pattern where two function
+ * parameters must either both be NULL or both NOT NULL.
+ */
+static bool
+has_arg_pair(FunctionCallInfo fcinfo, const char **pnames, int p1, int p2)
+{
+	/* if on param is NULL and the other NOT NULL, report an error */
+	if (PG_ARGISNULL(p1) != PG_ARGISNULL(p2))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be NULL when %s is NOT NULL",
+						pnames[(PG_ARGISNULL(p1)) ? p1 : p2],
+						pnames[(PG_ARGISNULL(p1)) ? p2 : p1])));
+
+	return (!PG_ARGISNULL(p1));
+}
+
+/*
+ * Test if the type is a scalar for MCELEM purposes
+ */
+static bool
+type_is_scalar(Oid typid)
+{
+	HeapTuple	tp;
+	bool		result = false;
+
+	tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
+	if (HeapTupleIsValid(tp))
+	{
+		Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+
+		result = (!OidIsValid(typtup->typanalyze));
+		ReleaseSysCache(tp);
+	}
+	return result;
+}
+
+static int
+value_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	if (arr->ndims != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s cannot be a multidimensional array", name)));
+
+	return arr->dims[0];
+}
+
+/*
+ * Convenience routine to encapsulate all of the steps needed for any
+ * value array.
+ */
+static int
+value_not_null_array_len(ExpandedArrayHeader *arr, const char *name)
+{
+	const int	nelems = value_array_len(arr, name);
+
+	if (nelems > 0)
+	{
+		deconstruct_expanded_array(arr);
+
+		/* if there's a nulls array, all values must be false */
+		if (arr->dnulls != NULL)
+			for (int i = 0; i < nelems; i++)
+				if (arr->dnulls[i])
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("%s array cannot contain NULL values", name)));
+	}
+
+	return nelems;
+}
+
+/*
+ * Fetch datatype information, this is needed to derive the proper staopN
+ * and stacollN values.
+ *
+ * If this relation is an index and that index has expressions in it, and
+ * the attnum specified is known to be an expression, then we must walk
+ * the list attributes up to the specified attnum to get the right
+ * expression.
+ *
+ */
+static TypeCacheEntry *
+get_attr_stat_type(Relation rel, Name attname,
+				   int16 *attnum, int32 *typmod, Oid *typcoll)
+{
+	Oid			relid = RelationGetRelid(rel);
+	Form_pg_attribute attr;
+	HeapTuple	atup;
+	Oid			typid;
+
+	atup = SearchSysCache2(ATTNAME, ObjectIdGetDatum(relid),
+						   NameGetDatum(attname));
+
+	/* Attribute not found */
+	if (!HeapTupleIsValid(atup))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s has no attname %s",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	attr = (Form_pg_attribute) GETSTRUCT(atup);
+	if (attr->attisdropped)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("Relation %s attname %s is dropped",
+						RelationGetRelationName(rel),
+						NameStr(*attname))));
+
+	*attnum = attr->attnum;
+
+	if ((rel->rd_rel->relkind == RELKIND_INDEX
+		 || (rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX))
+		&& (rel->rd_indexprs != NIL)
+		&& (rel->rd_index->indkey.values[attr->attnum - 1] == 0))
+	{
+		ListCell   *indexpr_item = list_head(rel->rd_indexprs);
+		Node	   *expr;
+
+		for (int i = 0; i < attr->attnum - 1; i++)
+			if (rel->rd_index->indkey.values[i] == 0)
+				indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
+
+		if (indexpr_item == NULL)	/* shouldn't happen */
+			elog(ERROR, "too few entries in indexprs list");
+
+		expr = (Node *) lfirst(indexpr_item);
+
+		typid = exprType(expr);
+		*typmod = exprTypmod(expr);
+
+		/*
+		 * If a collation has been specified for the index column, use that in
+		 * preference to anything else; but if not, fall back to whatever we
+		 * can get from the expression.
+		 */
+		if (OidIsValid(attr->attcollation))
+			*typcoll = attr->attcollation;
+		else
+			*typcoll = exprCollation(expr);
+	}
+	else
+	{
+		typid = attr->atttypid;
+		*typmod = attr->atttypmod;
+		*typcoll = attr->attcollation;
+	}
+	ReleaseSysCache(atup);
+
+	/* if it's a multirange, step down to the range type */
+	if (type_is_multirange(typid))
+		typid = get_multirange_range(typid);
+
+	return lookup_type_cache(typid, 
+							 TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR);
+}
+
+
+/*
+ * The null_frac statistic must be in [0.0,1.0].
+ */
+static void
+validate_null_frac(float4 null_frac, const char *statname)
+{
+	const float4 min = 0.0;
+	const float4 max = 1.0;
+
+	if ((null_frac < min) || (null_frac > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						statname, null_frac, min, max)));
+}
+
+/*
+ * The avg_width statistic must be non-negative.
+ */
+static void
+validate_avg_width(int32 avg_width, const char *statname)
+{
+	const int	min = 0;
+
+	if (avg_width < min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %d must be >= %d", statname, avg_width, min)));
+}
+
+/*
+ * The n_distinct statistic cannot be below -1.0.
+ */
+static void
+validate_n_distinct(float4 n_distinct, const char *statname)
+{
+	const float4 min = -1.0;
+
+	if (n_distinct < min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f must be >= %.1f",
+						statname, n_distinct, min)));
+}
+
+/*
+ * Check correctness of MCV statistics pair.
+ *
+ * The length of the freqs array must be equal to the length of the values
+ * array. Neither array can contain NULL elements.
+ *
+ * The elements in the freqs array must be monotonically nondecreasing, and the
+ * sum of values in the array theoretically should not exceed 1.0, but we use a
+ * more relaxed limit to allow for compounded rounding errors.
+ */
+static void
+validate_mcv(Datum freqs, Datum values, const char *freqsname,
+			 const char *valuesname)
+{
+	ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+	ExpandedArrayHeader *valsarr = DatumGetExpandedArray(values);
+
+	int			nvals = value_array_len(valsarr, valuesname);
+	int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+
+	if (nfreqs != nvals)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has %d elements, but %s has %d elements, "
+						"but they must be equal",
+						freqsname, nfreqs, valuesname, nvals)));
+
+	/*
+	 * check that freqs sum to <= 1.0 or some number slightly higer to allow
+	 * for compounded rounding errors.
+	 */
+	if (nfreqs >= 1)
+	{
+		const float4 freqsummax = 1.1;
+
+		float4		prev = DatumGetFloat4(freqsarr->dvalues[0]);
+		float4		freqsum = prev;
+
+		for (int i = 1; i < nfreqs; i++)
+		{
+			float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+			if (f > prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in descending "
+								"order, but %f > %f",
+								freqsname, f, prev)));
+
+			freqsum += f;
+			prev = f;
+		}
+
+		if (freqsum > freqsummax)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("The sum of elements in %s must not exceed "
+							"%.2f but is %f",
+							freqsname, freqsummax, freqsum)));
+	}
+}
+
+/*
+ * Check correctness of Histogram Bounds statistics.
+ *
+ * The array represents a histogram, which means that the values must be in
+ * monotonically non-decreasing order.
+ *
+ * If the attribute datatype in question uses collations then this validation
+ * has the chance to turn up any discrepancies in the source and destination
+ * collations if the datatype uses collations.
+ */
+static void
+validate_histogram_bounds(Datum stavalues, Datum srcstrvalue,
+						  Oid ltopr, Oid typcollation,
+						  const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+	SortSupportData ssupd;
+
+	int			nelems = value_not_null_array_len(arr, statname);
+
+	memset(&ssupd, 0, sizeof(ssupd));
+	ssupd.ssup_cxt = CurrentMemoryContext;
+	ssupd.ssup_collation = typcollation;
+	ssupd.ssup_nulls_first = false;
+	ssupd.abbreviate = false;
+
+	PrepareSortSupportFromOrderingOp(ltopr, &ssupd);
+
+	/*
+	 * Array should be in * monotonically non-decreasing order. If we every
+	 * find a case where [n] > [n+1], raise an error.
+	 */
+	for (int i = 1; i < nelems; i++)
+	{
+		Datum		a = arr->dvalues[i - 1];
+		Datum		b = arr->dvalues[i];
+
+		if (ssupd.comparator(a, b, &ssupd) > 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s values must be in ascending order %s",
+							statname, TextDatumGetCString(srcstrvalue))));
+
+	}
+}
+
+/*
+ * Check correctness of Correlation statistics.
+ *
+ * Correlation must be in [-1.0,1,0].
+ */
+static void
+validate_correlation(float4 corr, const char *statname)
+{
+	const float4 min = -1.0;
+	const float4 max = 1.0;
+
+	if ((corr < min) || (corr > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						statname, corr, min, max)));
+}
+
+/*
+ * Check correctness of Most Common Elements statistics.
+ *
+ * Neither array can contain NULL elements.
+ *
+ * The values array must be in monotonically incresing order. Elements may
+ * not repeat.
+ *
+ * Every element in the values array must have a corresponding element in the
+ * freqs array. The freqs array will have two additional elements, representing
+ * the frequency lower bound (LB) and frequency upper bound UB). The freqs
+ * array may have an optoinal extra value representing the null fraction of
+ * values in the column.
+ *
+ * The null fraction, LB and UB must be between [0.0,1.0].
+ *
+ * The LB must be <= the UB.
+ */
+static void
+validate_most_common_elements(Datum freqs, Datum elements, Datum srcstrvalue,
+							  const char *freqsname, const char *elemsname,
+							  Oid ltopr, Oid typcollation)
+{
+	ExpandedArrayHeader *freqsarr = DatumGetExpandedArray(freqs);
+	ExpandedArrayHeader *elemsarr = DatumGetExpandedArray(elements);
+
+	int			nfreqs = value_not_null_array_len(freqsarr, freqsname);
+	int			nelems = value_not_null_array_len(elemsarr, elemsname);
+
+	/*
+	 * The mcelem freqs array has either 2 or 3 additional values: the min
+	 * frequency, the max frequency, the optional null frequency.
+	 */
+	const int	nfreqsmin = nelems + 2;
+	const int	nfreqsmax = nelems + 3;
+
+	/*
+	 * the freqlowbound and freqhighbound must themselves be valid percentages
+	 */
+	const float4 frac_min = 0.0;
+	const float4 frac_max = 1.0;
+
+	float4		freqlowbound;
+	float4		freqhighbound;
+
+	if (nfreqs <= 0)
+		return;
+
+	if ((nfreqs < nfreqsmin) || (nfreqs > nfreqsmax))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has %d elements, but must have between "
+						"%d and %d because %s has %d elements",
+						freqsname, nfreqs, nfreqsmin, nfreqsmax,
+						elemsname, nelems)));
+
+	/* first freq element past the length of the values is the min */
+	freqlowbound = DatumGetFloat4(freqsarr->dvalues[nelems]);
+	if ((freqlowbound < frac_min) || (freqlowbound > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %s frequency %f is out of "
+						"range %.1f to %.1f",
+						freqsname, "minimum", freqlowbound,
+						frac_min, frac_max)));
+
+	/* second freq element past the length of the values is the max */
+	freqhighbound = DatumGetFloat4(freqsarr->dvalues[nelems + 1]);
+	if ((freqhighbound < frac_min) || (freqhighbound > frac_max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %s frequency %f is out of "
+						"range %.1f to %.1f",
+						freqsname, "maximum", freqhighbound,
+						frac_min, frac_max)));
+
+	/* low bound must be < high bound */
+	if (freqlowbound > freqhighbound)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s frequency low bound %f cannot be greater "
+						"than high bound %f",
+						freqsname, freqlowbound, freqhighbound)));
+
+	/*
+	 * third freq element past the length of the values is the null frac
+	 */
+	if (nfreqs == nelems + 3)
+	{
+		float4		freqnullpct;
+
+		freqnullpct = DatumGetFloat4(freqsarr->dvalues[nelems + 2]);
+
+		if ((freqnullpct < frac_min) || (freqnullpct > frac_max))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s %s frequency %f is out of "
+							"range %.1f to %.1f",
+							freqsname, "null", freqnullpct,
+							frac_min, frac_max)));
+	}
+
+	/*
+	 * All the freqs that match up to a val must be between low/high bounds
+	 * (which is never less strict than frac_min/frac_max)
+	 *
+	 * Also, these frequencies do not sum to a number <= 1.0 as is the case
+	 * with MC_FREQS.
+	 */
+	for (int i = 0; i < nelems; i++)
+	{
+		float4		f = DatumGetFloat4(freqsarr->dvalues[i]);
+
+		if ((f < freqlowbound) || (f > freqhighbound))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s frequency %f is out of range %f to %f",
+							freqsname, f, freqlowbound, freqhighbound)));
+	}
+
+	/*
+	 * All the elements must be unique and in ascending order.
+	 */
+	if (nelems > 1)
+	{
+		SortSupportData ssupd;
+
+		memset(&ssupd, 0, sizeof(ssupd));
+		ssupd.ssup_cxt = CurrentMemoryContext;
+		ssupd.ssup_collation = typcollation;
+		ssupd.ssup_nulls_first = false;
+		ssupd.abbreviate = false;
+
+		PrepareSortSupportFromOrderingOp(ltopr, &ssupd);
+
+		for (int i = 1; i < nelems; i++)
+		{
+			Datum		a = elemsarr->dvalues[i - 1];
+			Datum		b = elemsarr->dvalues[i];
+
+			if (ssupd.comparator(a, b, &ssupd) >= 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s values must be unqiue and in ascending order %s",
+								elemsname, TextDatumGetCString(srcstrvalue))));
+
+		}
+	}
+}
+
+/*
+ * Check correctness of Distinct Elements Count Histogram statistics.
+ *
+ * All elements must be >= 0.0, and must be in monotonically nonincreasing
+ * order.
+ */
+static void
+validate_distinct_elements_count_histogram(Datum stanumbers,
+										   const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stanumbers);
+
+	const float4 last_min = 0.0;
+
+	int			nelems = value_not_null_array_len(arr, statname);
+	float4		last;
+
+	/* Last element must be >= 0 */
+	last = DatumGetFloat4(arr->dvalues[nelems - 1]);
+	if (last < last_min)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s has last element %f < %.1f",
+						statname, last, last_min)));
+
+	/* all other elements must be monotonically nondecreasing */
+	if (nelems > 1)
+	{
+		float4		prev = DatumGetFloat4(arr->dvalues[0]);
+
+		for (int i = 1; i < nelems - 1; i++)
+		{
+			float4		f = DatumGetFloat4(arr->dvalues[i]);
+
+			if (f < prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in ascending "
+								"order, but %f > %f",
+								statname, prev, f)));
+
+			prev = f;
+		}
+	}
+}
+
+/*
+ * Validate Range Bound Histogram statistic.
+ *
+ * The values in this array are ranges of the same scalar type as the attribute
+ * in question and cannot be empty. However those ranges are being used to
+ * represent two parallel arrays with inclusive/exclusive bounds, representing
+ * the histogram of lower bounds and the histogram of upper bounds. Each of
+ * those two arrays must each be monotonically nondecreasing.
+ */
+
+static void
+validate_bounds_histogram(Datum stavalues, Datum strvalue,
+						  TypeCacheEntry *typcache, const char *statname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(stavalues);
+
+	int			nelems = value_not_null_array_len(arr, statname);
+	RangeType  *prevrange;
+	RangeBound	prevlower;
+	RangeBound	prevupper;
+	bool		empty;
+
+	if (nelems <= 0)
+		return;
+
+	/* check first element for emptiness */
+	prevrange = DatumGetRangeTypeP(arr->dvalues[0]);
+	range_deserialize(typcache, prevrange, &prevlower,
+					  &prevupper, &empty);
+
+	if (empty)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s array bounds cannot have empty elements",
+						statname)));
+
+	/*
+	 * For element N, verify that: lower_bound(N) <= lower_bound(N+1), and
+	 * upper_bound(N) <= upper_bound(N+1)
+	 */
+	for (int i = 1; i < nelems; i++)
+	{
+		RangeType  *range = DatumGetRangeTypeP(arr->dvalues[i]);
+		RangeBound	lower;
+		RangeBound	upper;
+
+		range_deserialize(typcache, range, &lower, &upper, &empty);
+
+		if (empty)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array bounds cannot have empty elements",
+							statname)));
+
+		if (range_cmp_bounds(typcache, &prevlower, &lower) == 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array %s bounds must be in ascending order",
+							statname, "lower")));
+
+		if (range_cmp_bounds(typcache, &prevupper, &upper) == 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s array %s bounds must be in ascending order",
+							statname, "upper")));
+
+		memcpy(&lower, &prevlower, sizeof(RangeBound));
+		memcpy(&upper, &prevupper, sizeof(RangeBound));
+	}
+}
+
+/*
+ * Validate Range Length Histogram statistic pair.
+ *
+ * The empty_frac must be between in [0.0,1.0].
+ *
+ * rlhist is a histogram of float8[], so it must be in monotonically
+ * nondecreasing order.
+ */
+static void
+validate_range_length_histogram(Datum rlhist, float4 empty_frac,
+								const char *histname,
+								const char *fracname)
+{
+	ExpandedArrayHeader *arr = DatumGetExpandedArray(rlhist);
+
+	int			nelems = value_not_null_array_len(arr, histname);
+
+	const float4 min = 0.0;
+	const float4 max = 1.0;
+
+	if ((empty_frac < min) || (empty_frac > max))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("%s %f is out of range %.1f to %.1f",
+						fracname, empty_frac, min, max)));
+
+	if (nelems > 1)
+	{
+		float8		prev = DatumGetFloat8(arr->dvalues[0]);
+
+		for (int i = 1; i < nelems; i++)
+		{
+			float8		f = DatumGetFloat8(arr->dvalues[i]);
+
+			if (f < prev)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("%s array values must be in ascending "
+								"order, but %f > %f",
+								histname, prev, f)));
+
+			prev = f;
+		}
+	}
+}
+
+/*
+ * Update the pg_statistic record.
+ */
+static void
+update_pg_statistic(Datum values[], bool nulls[])
+{
+	Relation	sd = table_open(StatisticRelationId, RowExclusiveLock);
+	CatalogIndexState indstate = CatalogOpenIndexes(sd);
+	HeapTuple	oldtup;
+	HeapTuple	stup;
+
+	/* Is there already a pg_statistic tuple for this attribute? */
+	oldtup = SearchSysCache3(STATRELATTINH,
+							 values[Anum_pg_statistic_starelid - 1],
+							 values[Anum_pg_statistic_staattnum - 1],
+							 values[Anum_pg_statistic_stainherit - 1]);
+
+	if (HeapTupleIsValid(oldtup))
+	{
+		/* Yes, replace it */
+		bool		replaces[Natts_pg_statistic];
+
+		for (int i = 0; i < Natts_pg_statistic; i++)
+			replaces[i] = true;
+
+		stup = heap_modify_tuple(oldtup, RelationGetDescr(sd),
+								 values, nulls, replaces);
+		ReleaseSysCache(oldtup);
+		CatalogTupleUpdateWithInfo(sd, &stup->t_self, stup, indstate);
+	}
+	else
+	{
+		/* No, insert new tuple */
+		stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
+		CatalogTupleInsertWithInfo(sd, stup, indstate);
+	}
+
+	heap_freetuple(stup);
+	CatalogCloseIndexes(indstate);
+	table_close(sd, NoLock);
+}
+
+/*
+ * Import statistics for a given relation attribute.
+ *
+ * This will insert/replace a row in pg_statistic for the given relation and
+ * attribute name.
+ *
+ * The function takes input parameters that correspond to columns in the view
+ * pg_stats.
+ *
+ * Of those, the columns attname, inherited, null_frac, avg_width, and
+ * n_distinct all correspond to NOT NULL columns in pg_statistic. These
+ * parameters have no default value and passing NULL to them will result
+ * in an error.
+ *
+ * If there is no attribute with a matching attname in the relation, the
+ * function will raise an error. Likewise for setting inherited statistics
+ * on a table that is not partitioned.
+ *
+ * The remaining parameters all belong to a specific stakind. Some stakinds
+ * have multiple parameters, and in those cases both parameters must be
+ * NOT NULL or both NULL, otherwise an error will be raised.
+ *
+ * Omitting a parameter or explicitly passing NULL means that that particular
+ * stakind is not associated with the attribute.
+ *
+ * Parameters that are NOT NULL will be inspected for consistency checks,
+ * any of which can raise an error.
+ *
+ * Parameters corresponding to ANYARRAY columns are instead passed in as text
+ * values, which is a valid input string for an array of the type or element
+ * type of the attribute. Any error generated by the array_in() function will
+ * in turn fail the function.
+ */
+Datum
+pg_set_attribute_stats(PG_FUNCTION_ARGS)
+{
+	/* Convenience enum to simulate naming the function arguments */
+	enum
+	{
+		P_RELATION = 0,			/* oid */
+		P_ATTNAME,				/* name */
+		P_INHERITED,			/* bool */
+		P_NULL_FRAC,			/* float4 */
+		P_AVG_WIDTH,			/* int32 */
+		P_N_DISTINCT,			/* float4 */
+		P_MC_VALS,				/* text, null */
+		P_MC_FREQS,				/* float4[], null */
+		P_HIST_BOUNDS,			/* text, null */
+		P_CORRELATION,			/* float4, null */
+		P_MC_ELEMS,				/* text, null */
+		P_MC_ELEM_FREQS,		/* float4[], null */
+		P_ELEM_COUNT_HIST,		/* float4[], null */
+		P_RANGE_LENGTH_HIST,	/* text, null */
+		P_RANGE_EMPTY_FRAC,		/* float4, null */
+		P_RANGE_BOUNDS_HIST,	/* text, null */
+		P_NUM_PARAMS
+	};
+
+	/* names of arguments indexed by above enum */
+	const char *param_names[] = {
+		"relation",
+		"attname",
+		"inherited",
+		"null_frac",
+		"avg_width",
+		"n_distinct",
+		"most_common_vals",
+		"most_common_freqs",
+		"histogram_bounds",
+		"correlation",
+		"most_common_elems",
+		"most_common_elem_freqs",
+		"elem_count_histogram",
+		"range_length_histogram",
+		"range_empty_frac",
+		"range_bounds_histogram"
+	};
+
+	Oid			relid;
+	Name		attname;
+	Relation	rel;
+
+	TypeCacheEntry *typcache;
+	TypeCacheEntry *basetypcache;
+
+	int16		attnum;
+	int32		typmod;
+	Oid			typcoll;
+
+	Datum		values[Natts_pg_statistic] = {0};
+	bool		nulls[Natts_pg_statistic] = {false};
+
+	FmgrInfo	finfo;
+
+	bool		has_mcv;
+	bool		has_mc_elems;
+	bool		has_rl_hist;
+	int			stakind_count;
+
+	int			k = 0;
+
+	/*
+	 * A null in a required parameter is an error.
+	 */
+	for (int i = P_RELATION; i <= P_N_DISTINCT; i++)
+		if (PG_ARGISNULL(i))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("%s cannot be NULL", param_names[i])));
+
+	/*
+	 * Check all parameter pairs up front.
+	 */
+	has_mcv = has_arg_pair(fcinfo, param_names,
+						   P_MC_VALS, P_MC_FREQS);
+	has_mc_elems = has_arg_pair(fcinfo, param_names,
+								P_MC_ELEMS, P_MC_ELEM_FREQS);
+	has_rl_hist = has_arg_pair(fcinfo, param_names,
+							   P_RANGE_LENGTH_HIST, P_RANGE_EMPTY_FRAC);
+
+	/*
+	 * If a caller specifies more stakind-stats than we have slots to store
+	 * them, raise an error.
+	 */
+	stakind_count = (int) has_mcv + (int) has_mc_elems + (int) has_rl_hist +
+		(int) !PG_ARGISNULL(P_HIST_BOUNDS) +
+		(int) !PG_ARGISNULL(P_CORRELATION) +
+		(int) !PG_ARGISNULL(P_ELEM_COUNT_HIST) +
+		(int) !PG_ARGISNULL(P_RANGE_BOUNDS_HIST);
+
+	if (stakind_count > STATISTIC_NUM_SLOTS)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("imported statistics must have a maximum of %d slots "
+						"but %d given",
+						STATISTIC_NUM_SLOTS, stakind_count)));
+
+	relid = PG_GETARG_OID(P_RELATION);
+
+	rel = relation_open(relid, ShareUpdateExclusiveLock);
+
+	check_relation_permissions(rel);
+
+	attname = PG_GETARG_NAME(P_ATTNAME);
+	typcache = get_attr_stat_type(rel, attname, &attnum, &typmod, &typcoll);
+
+	/*
+	 * Derive base type if we have stats kinds that need it.
+	 *
+	 * This duplicates some type-specific logic found in various typanalyze
+	 * functions which are called from vacuum's examine_attribute(), but
+	 * using that directly has proven awkward.
+	 */
+	if (has_mc_elems || !PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		Oid basetypid;
+
+		if (typcache->type_id == TSVECTOROID)
+		{
+			/* tsvectors always have a text oid base type and default collation */
+			basetypid = TEXTOID;
+			typcoll = DEFAULT_COLLATION_OID;
+		}
+		else if (typcache->typtype == TYPTYPE_RANGE)
+			basetypid = get_range_subtype(typcache->type_id);
+		else
+			basetypid = get_base_element_type(typcache->type_id);
+
+		/* not finding a basetype means we already had it */
+		if (basetypid == InvalidOid)
+			basetypid = typcache->type_id;
+
+		/* The stats need the eq_opr, but validation needs the lt_opr */
+		basetypcache = lookup_type_cache(basetypid,
+										 TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR);
+	}
+
+	/* P_HIST_BOUNDS and P_CORRELATION must have a type < operator */
+	if (typcache->lt_opr == InvalidOid)
+		for (int i = P_HIST_BOUNDS; i <= P_CORRELATION; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s cannot "
+								"have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Scalar types can't have P_MC_ELEMS, P_MC_ELEM_FREQS, P_ELEM_COUNT_HIST */
+	if (type_is_scalar(typcache->type_id))
+		for (int i = P_MC_ELEMS; i <= P_ELEM_COUNT_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is a scalar type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	/* Only range types can have P_RANGE_x */
+	if ((typcache->typtype != TYPTYPE_RANGE) &&
+		(typcache->typtype != TYPTYPE_RANGE))
+		for (int i = P_RANGE_LENGTH_HIST; i <= P_RANGE_BOUNDS_HIST; i++)
+			if (!PG_ARGISNULL(i))
+				ereport(ERROR,
+						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+						 errmsg("Relation %s attname %s is not a range type, "
+								"cannot have stats of type %s",
+								RelationGetRelationName(rel),
+								NameStr(*attname),
+								param_names[i])));
+
+	validate_null_frac(PG_GETARG_FLOAT4(P_NULL_FRAC),
+					   param_names[P_NULL_FRAC]);
+	validate_avg_width(PG_GETARG_INT32(P_AVG_WIDTH),
+					   param_names[P_AVG_WIDTH]);
+	validate_n_distinct(PG_GETARG_FLOAT4(P_N_DISTINCT),
+						param_names[P_N_DISTINCT]);
+	values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
+	values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attnum);
+	values[Anum_pg_statistic_stainherit - 1] = PG_GETARG_DATUM(P_INHERITED);
+	values[Anum_pg_statistic_stanullfrac - 1] = PG_GETARG_DATUM(P_NULL_FRAC);
+	values[Anum_pg_statistic_stawidth - 1] = PG_GETARG_DATUM(P_AVG_WIDTH);
+	values[Anum_pg_statistic_stadistinct - 1] = PG_GETARG_DATUM(P_N_DISTINCT);
+
+	fmgr_info(F_ARRAY_IN, &finfo);
+
+	/* MC_VALS && MC_FREQS => STATISTIC_KIND_MCV */
+	if (has_mcv)
+	{
+		Datum		stanumbers = PG_GETARG_DATUM(P_MC_FREQS);
+		Datum		stavalues = cast_stavalues(&finfo, PG_GETARG_DATUM(P_MC_VALS),
+											   typcache->type_id, typmod);
+
+		validate_mcv(stanumbers, stavalues, param_names[P_MC_FREQS],
+					 param_names[P_MC_VALS]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCV);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* HIST_BOUNDS => STATISTIC_KIND_HISTOGRAM */
+	if (!PG_ARGISNULL(P_HIST_BOUNDS))
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_HIST_BOUNDS);
+		Datum		stavalues = cast_stavalues(&finfo, strvalue,
+											   typcache->type_id, typmod);
+
+		validate_histogram_bounds(stavalues, strvalue, typcache->lt_opr, typcoll,
+								  param_names[P_HIST_BOUNDS]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->lt_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* CORRELATION => STATISTIC_KIND_CORRELATION */
+	if (!PG_ARGISNULL(P_CORRELATION))
+	{
+		Datum		elem = PG_GETARG_DATUM(P_CORRELATION);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+		Datum		stanumbers = PointerGetDatum(arry);
+
+		validate_correlation(DatumGetFloat4(elem), param_names[P_CORRELATION]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_CORRELATION);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(typcache->lt_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/* MC_ELEMS && MC_ELEM_FREQS => STATISTIC_KIND_MCELEM */
+	if (has_mc_elems)
+	{
+		Datum		srcstrvalue = PG_GETARG_DATUM(P_MC_ELEMS);
+		Datum		stanumbers = PG_GETARG_DATUM(P_MC_ELEM_FREQS);
+		Datum		stavalues = cast_stavalues(&finfo, srcstrvalue,
+											   basetypcache->type_id, typmod);
+
+		validate_most_common_elements(stanumbers, stavalues, srcstrvalue,
+									  param_names[P_MC_ELEM_FREQS],
+									  param_names[P_MC_ELEMS],
+									  basetypcache->lt_opr, typcoll);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_MCELEM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(basetypcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/* ELEM_COUNT_HIST => STATISTIC_KIND_DECHIST */
+	if (!PG_ARGISNULL(P_ELEM_COUNT_HIST))
+	{
+		Datum		stanumbers = PG_GETARG_DATUM(P_ELEM_COUNT_HIST);
+
+		validate_distinct_elements_count_histogram(stanumbers,
+												   param_names[P_ELEM_COUNT_HIST]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_DECHIST);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(basetypcache->eq_opr);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(typcoll);
+
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = stanumbers;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+
+		k++;
+	}
+
+	/*
+	 * RANGE_BOUNDS_HIST => STATISTIC_KIND_BOUNDS_HISTOGRAM
+	 *
+	 * This stakind appears before STATISTIC_KIND_BOUNDS_HISTOGRAM even though
+	 * it is numerically greater, and all other stakinds appear in numerical
+	 * order. We duplicate this quirk to make before/after tests of
+	 * pg_statistic records easier.
+	 */
+	if (!PG_ARGISNULL(P_RANGE_BOUNDS_HIST))
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_BOUNDS_HIST);
+		Datum		stavalues = cast_stavalues(&finfo, strvalue,
+											   typcache->type_id, typmod);
+
+		validate_bounds_histogram(stavalues, strvalue, typcache,
+								  param_names[P_RANGE_BOUNDS_HIST]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_BOUNDS_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+
+		k++;
+	}
+
+	/*
+	 * P_RANGE_LENGTH_HIST && P_RANGE_EMPTY_FRAC =>
+	 * STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM
+	 */
+	if (has_rl_hist)
+	{
+		Datum		strvalue = PG_GETARG_DATUM(P_RANGE_LENGTH_HIST);
+
+		/* The anyarray is always a float8[] for this stakind */
+		Datum		stavalues = cast_stavalues(&finfo, strvalue, FLOAT8OID, 0);
+		Datum		elem = PG_GETARG_DATUM(P_RANGE_EMPTY_FRAC);
+		Datum		elems[] = {elem};
+		ArrayType  *arry = construct_array_builtin(elems, 1, FLOAT4OID);
+
+		validate_range_length_histogram(stavalues,
+										DatumGetFloat4(elem),
+										param_names[P_RANGE_LENGTH_HIST],
+										param_names[P_RANGE_EMPTY_FRAC]);
+
+		values[Anum_pg_statistic_stakind1 - 1 + k] =
+			Int16GetDatum(STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(Float8LessOperator);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stanumbers1 - 1 + k] = PointerGetDatum(arry);
+		values[Anum_pg_statistic_stavalues1 - 1 + k] = stavalues;
+		k++;
+	}
+
+	/* fill in all remaining slots */
+	for (; k < STATISTIC_NUM_SLOTS; k++)
+	{
+		values[Anum_pg_statistic_stakind1 - 1 + k] = Int16GetDatum(0);
+		values[Anum_pg_statistic_staop1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		values[Anum_pg_statistic_stacoll1 - 1 + k] = ObjectIdGetDatum(InvalidOid);
+		nulls[Anum_pg_statistic_stanumbers1 - 1 + k] = true;
+		nulls[Anum_pg_statistic_stavalues1 - 1 + k] = true;
+	}
+
+	update_pg_statistic(values, nulls);
+
+	relation_close(rel, NoLock);
+	PG_RETURN_VOID();
+}
diff --git a/src/test/regress/expected/stats_export_import.out b/src/test/regress/expected/stats_export_import.out
new file mode 100644
index 0000000000..482f1eb2a3
--- /dev/null
+++ b/src/test/regress/expected/stats_export_import.out
@@ -0,0 +1,942 @@
+CREATE SCHEMA stats_export_import;
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+        0 |        -1 |             0
+(1 row)
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+ pg_set_relation_stats 
+-----------------------
+ 
+(1 row)
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+ERROR:  relpages cannot be NULL
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+ relpages | reltuples | relallvisible 
+----------+-----------+---------------
+      999 |       3.6 |         15000
+(1 row)
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  could not open relation with OID 0
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  relation cannot be NULL
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  attname cannot be NULL
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  inherited cannot be NULL
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width cannot be NULL
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+ERROR:  n_distinct cannot be NULL
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.1 |         2 |        0.3 |                  |                   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac -0.100000 is out of range 0.0 to 1.0
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+ERROR:  null_frac 1.100000 is out of range 0.0 to 1.0
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+ERROR:  avg_width -1 must be >= 0
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+ERROR:  n_distinct -1.100000 must be >= -1.0
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_vals cannot be NULL when most_common_freqs is NOT NULL
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+ERROR:  most_common_freqs cannot be NULL when most_common_vals is NOT NULL
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+ERROR:  most_common_freqs has 2 elements, but most_common_vals has 3 elements, but they must be equal
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+ERROR:  The sum of elements in most_common_freqs must not exceed 1.10 but is 1.400000
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 | {2,1,3}          | {0.3,0.25,0.05}   |                  |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+ERROR:  histogram_bounds array cannot contain NULL values
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+ERROR:  histogram_bounds values must be in ascending order {1,20,3,4}
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   | {1,2,3,4}        |             |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+ERROR:  correlation -1.100000 is out of range -1.0 to 1.0
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+ERROR:  correlation 1.100000 is out of range -1.0 to 1.0
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | id      | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |         0.5 |                   |                        |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type most_common_elems
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+ERROR:  most_common_elem_freqs cannot be NULL when most_common_elems is NOT NULL
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+ERROR:  most_common_elems cannot be NULL when most_common_elem_freqs is NOT NULL
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+ERROR:  most_common_elem_freqs has 2 elements, but must have between 4 and 5 because most_common_elems has 2 elements
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency 0.100000 is out of range 0.200000 to 0.300000
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elem_freqs frequency low bound 0.400000 cannot be greater than high bound 0.300000
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+ERROR:  most_common_elem_freqs null frequency -0.000100 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency -0.150000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs minimum frequency 1.500000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency -0.300000 is out of range 0.0 to 1.0
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+ERROR:  most_common_elem_freqs maximum frequency 3.000000 is out of range 0.0 to 1.0
+-- error mcelem values must be monotonically increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.3,0.2,0.3,0.0}'::real[]
+    );
+ERROR:  most_common_elems values must be unqiue and in ascending order {three,one}
+-- error mcelem values must be unique
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three,three}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.4,0.2,0.5,0.0}'::real[]
+    );
+ERROR:  most_common_elems values must be unqiue and in ascending order {one,three,three}
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             | {one,three}       | {0.3,0.2,0.2,0.3,0}    |                      |                        |                  | 
+(1 row)
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  Relation test attname id is a scalar type, cannot have stats of type elem_count_histogram
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array cannot contain NULL values
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ERROR:  elem_count_histogram array values must be in ascending order, but 1.000000 > 0.000000
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs |                                                                                            elem_count_histogram                                                                                             | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | tags    | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        | {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} |                        |                  | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_length_histogram
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac cannot be NULL when range_length_histogram is NOT NULL
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+ERROR:  range_length_histogram cannot be NULL when range_empty_frac is NOT NULL
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac -0.500000 is out of range 0.0 to 1.0
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ERROR:  range_empty_frac 1.500000 is out of range 0.0 to 1.0
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+ERROR:  range_length_histogram array values must be in ascending order, but Infinity > 499.000000
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac | range_bounds_histogram 
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      | {399,499,Infinity}     |              0.5 | 
+(1 row)
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  Relation test attname id is not a range type, cannot have stats of type range_bounds_histogram
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array lower bounds must be in ascending order
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  range_bounds_histogram array upper bounds must be in ascending order
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+     schemaname      | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram | range_length_histogram | range_empty_frac |        range_bounds_histogram        
+---------------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+----------------------+------------------------+------------------+--------------------------------------
+ stats_export_import | test      | arange  | f         |       0.5 |         2 |       -0.1 |                  |                   |                  |             |                   |                        |                      |                        |                  | {"[-1,1)","[0,4)","[1,4)","[1,100)"}
+(1 row)
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+ERROR:  imported statistics must have a maximum of 5 slots but 6 given
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+ pg_set_attribute_stats 
+------------------------
+ 
+(1 row)
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+   relname    | num_stats 
+--------------+-----------
+ is_odd       |         1
+ is_odd_clone |         1
+ test         |         5
+ test_clone   |         5
+(4 rows)
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
+ attname | stainherit | stanullfrac | stawidth | stadistinct | stakind1 | stakind2 | stakind3 | stakind4 | stakind5 | staop1 | staop2 | staop3 | staop4 | staop5 | stacoll1 | stacoll2 | stacoll3 | stacoll4 | stacoll5 | stanumbers1 | stanumbers2 | stanumbers3 | stanumbers4 | stanumbers5 | sv1 | sv2 | sv3 | sv4 | sv5 | direction 
+---------+------------+-------------+----------+-------------+----------+----------+----------+----------+----------+--------+--------+--------+--------+--------+----------+----------+----------+----------+----------+-------------+-------------+-------------+-------------+-------------+-----+-----+-----+-----+-----+-----------
+(0 rows)
+
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 5ac6e871f5..a7a4dfd411 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -28,7 +28,8 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
 # geometry depends on point, lseg, line, box, path, polygon, circle
 # horology depends on date, time, timetz, timestamp, timestamptz, interval
 # ----------
-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
+test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc stats_export_import
+
 
 # ----------
 # Load huge amounts of data
diff --git a/src/test/regress/sql/stats_export_import.sql b/src/test/regress/sql/stats_export_import.sql
new file mode 100644
index 0000000000..1a7d02a2c7
--- /dev/null
+++ b/src/test/regress/sql/stats_export_import.sql
@@ -0,0 +1,836 @@
+CREATE SCHEMA stats_export_import;
+
+CREATE TYPE stats_export_import.complex_type AS (
+    a integer,
+    b real,
+    c text,
+    d date,
+    e jsonb);
+
+CREATE TABLE stats_export_import.test(
+    id INTEGER PRIMARY KEY,
+    name text,
+    comp stats_export_import.complex_type,
+    arange int4range,
+    tags text[]
+);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, 999, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: relpages null
+SELECT pg_set_relation_stats('stats_export_import.test'::regclass, NULL, 3.6::real, 15000);
+
+SELECT relpages, reltuples, relallvisible FROM pg_class WHERE oid = 'stats_export_import.test'::regclass;
+
+-- error: object doesn't exist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => '0'::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: relation null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => NULL::oid,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: attname null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => NULL::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: inherited null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => NULL::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => NULL::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => NULL::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width null
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => NULL::real);
+
+-- ok: no stakinds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: null_frac < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => -0.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: null_frac > 1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 1.1::real,
+    avg_width => 2::integer,
+    n_distinct => 0.3::real);
+
+-- error: avg_width < 0
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => -1::integer,
+    n_distinct => 0.3::real);
+
+-- error: n_distinct < -1
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -1.1::real);
+
+-- error: mcv / mcf null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => NULL::text,
+    most_common_freqs => '{0.1,0.2,0.3}'::real[]
+    );
+
+-- error: mcv / mcf null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{1,2,3}'::text,
+    most_common_freqs => NULL::real[]
+    );
+
+-- error: mcv / mcf length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.2,0.1}'::real[]
+    );
+
+-- error: mcf sum bad
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.6,0.5,0.3}'::real[]
+    );
+
+-- ok: mcv+mcf
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: histogram elements null value
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,NULL,3,4}'::text
+    );
+-- error: histogram elements must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,20,3,4}'::text
+    );
+
+-- ok: histogram_bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    histogram_bounds => '{1,2,3,4}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: correlation low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => -1.1::real);
+
+-- error: correlation high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 1.1::real);
+
+-- ok: correlation
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    correlation => 0.5::real);
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'id';
+
+-- error: scalars can't have mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{1,3}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,two}'::text,
+    most_common_elem_freqs => NULL::real[]
+    );
+
+-- error: mcelem / mcelem null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => NULL::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3}'::real[]
+    );
+
+-- error: mcelem / mcelem length mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2}'::real[]
+    );
+
+-- error: mcelem freq element out of bounds
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.1,0.2,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq low-high mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,0.3,0.0}'::real[]
+    );
+
+-- error: mcelem freq null pct invalid
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,-0.0001}'::real[]
+    );
+
+-- error: mcelem freq bad low bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,-0.15,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad low bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,1.5,0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,-0.3,0.1}'::real[]
+    );
+
+-- error: mcelem freq bad high bound high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.4,3.0,0.1}'::real[]
+    );
+
+-- error mcelem values must be monotonically increasing
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{three,one}'::text,
+    most_common_elem_freqs => '{0.3,0.3,0.2,0.3,0.0}'::real[]
+    );
+-- error mcelem values must be unique
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three,three}'::text,
+    most_common_elem_freqs => '{0.3,0.4,0.4,0.2,0.5,0.0}'::real[]
+    );
+
+-- ok: mcelem 
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_elems => '{one,three}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram null element
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,NULL,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- error: elem_count_histogram must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+-- ok: elem_count_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'tags'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    elem_count_histogram => '{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}'::real[]
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'tags';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac range_length_hist null mismatch part 2
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real
+    );
+-- error: range_empty_frac low
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_empty_frac high
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 1.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+-- error: range_length_histogram not ascending
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,Infinity,499}'::text
+    );
+-- ok: range_empty_frac + range_length_hist
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_empty_frac => 0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: scalars can't have range stats
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'id'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist low bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[-2,4)","[1,4)","[1,100)"}'::text
+    );
+-- error: range_bound_hist high bounds must be in order
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,11)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+-- ok: range_bounds_histogram
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+
+SELECT *
+FROM pg_stats
+WHERE schemaname = 'stats_export_import'
+AND tablename = 'test'
+AND inherited = false
+AND attname = 'arange';
+
+-- error: exceed STATISTIC_NUM_SLOTS
+SELECT pg_catalog.pg_set_attribute_stats(
+    relation => 'stats_export_import.test'::regclass,
+    attname => 'arange'::name,
+    inherited => false::boolean,
+    null_frac => 0.5::real,
+    avg_width => 2::integer,
+    n_distinct => -0.1::real,
+    most_common_vals => '{2,1,3}'::text,
+    most_common_freqs => '{0.3,0.25,0.05}'::real[],
+    histogram_bounds => '{1,2,3,4}'::text,
+    correlation => 1.1::real,
+    most_common_elems => '{3,1}'::text,
+    most_common_elem_freqs => '{0.3,0.2,0.2,0.3,0.0}'::real[],
+    range_empty_frac => -0.5::real,
+    range_length_histogram => '{399,499,Infinity}'::text,
+    range_bounds_histogram => '{"[-1,1)","[0,4)","[1,4)","[1,100)"}'::text
+    );
+--
+-- Test the ability to exactly copy data from one table to an identical table,
+-- correctly reconstructing the stakind order as well as the staopN and
+-- stacollN values. Because oids are not stable across databases, we can only
+-- test this when the source and destination are on the same database
+-- instance. For that reason, we borrow and adapt a query found in fe_utils
+-- and used by pg_dump/pg_upgrade.
+--
+INSERT INTO stats_export_import.test
+SELECT 1, 'one', (1, 1.1, 'ONE', '2001-01-01', '{ "xkey": "xval" }')::stats_export_import.complex_type, int4range(1,4), array['red','green']
+UNION ALL
+SELECT 2, 'two', (2, 2.2, 'TWO', '2002-02-02', '[true, 4, "six"]')::stats_export_import.complex_type,  int4range(1,4), array['blue','yellow']
+UNION ALL
+SELECT 3, 'tre', (3, 3.3, 'TRE', '2003-03-03', NULL)::stats_export_import.complex_type, int4range(-1,1), array['"orange"', 'purple', 'cyan']
+UNION ALL
+SELECT 4, 'four', NULL, int4range(0,100), NULL;
+
+CREATE INDEX is_odd ON stats_export_import.test(((comp).a % 2 = 1));
+
+-- Generate statistics on table with data
+ANALYZE stats_export_import.test;
+
+CREATE TABLE stats_export_import.test_clone ( LIKE stats_export_import.test );
+
+CREATE INDEX is_odd_clone ON stats_export_import.test_clone(((comp).a % 2 = 1));
+
+--
+-- Turn off ECHO for the transfer, because the actual stats generated by
+-- ANALYZE could change, and we don't care about the actual stats, we care
+-- about the ability to transfer them to another relation.
+--
+\set orig_ECHO :ECHO
+\set ECHO none
+
+SELECT
+    format('SELECT pg_catalog.pg_set_attribute_stats( '
+            || 'relation => %L::regclass::oid, attname => %L::name, '
+            || 'inherited => %L::boolean, null_frac => %L::real, '
+            || 'avg_width => %L::integer, n_distinct => %L::real, '
+            || 'most_common_vals => %L::text, '
+            || 'most_common_freqs => %L::real[], '
+            || 'histogram_bounds => %L::text, '
+            || 'correlation => %L::real, '
+            || 'most_common_elems => %L::text, '
+            || 'most_common_elem_freqs => %L::real[], '
+            || 'elem_count_histogram => %L::real[], '
+            || 'range_length_histogram => %L::text, '
+            || 'range_empty_frac => %L::real, '
+            || 'range_bounds_histogram => %L::text) ',
+        'stats_export_import.' || s.tablename || '_clone', s.attname,
+        s.inherited, s.null_frac,
+        s.avg_width, s.n_distinct,
+        s.most_common_vals, s.most_common_freqs, s.histogram_bounds,
+        s.correlation, s.most_common_elems, s.most_common_elem_freqs,
+        s.elem_count_histogram, s.range_length_histogram,
+        s.range_empty_frac, s.range_bounds_histogram)
+FROM pg_catalog.pg_stats AS s
+WHERE s.schemaname = 'stats_export_import'
+AND s.tablename IN ('test', 'is_odd')
+\gexec
+
+-- restore ECHO to original value
+\set ECHO :orig_ECHO
+
+SELECT c.relname, COUNT(*) AS num_stats
+FROM pg_class AS c
+JOIN pg_statistic s ON s.starelid = c.oid
+WHERE c.relnamespace = 'stats_export_import'::regnamespace
+AND c.relname IN ('test', 'test_clone', 'is_odd', 'is_odd_clone')
+GROUP BY c.relname
+ORDER BY c.relname;
+
+-- check test minus test_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass;
+
+-- check test_clone minus test
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'test_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.test'::regclass;
+
+-- check is_odd minus is_odd_clone
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass;
+
+-- check is_odd_clone minus is_odd
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd_clone'::regclass
+EXCEPT
+SELECT
+    a.attname, s.stainherit, s.stanullfrac, s.stawidth, s.stadistinct,
+    s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5,
+    s.staop1, s.staop2, s.staop3, s.staop4, s.staop5,
+    s.stacoll1, s.stacoll2, s.stacoll3, s.stacoll4, s.stacoll5,
+    s.stanumbers1, s.stanumbers2, s.stanumbers3, s.stanumbers4, s.stanumbers5,
+    s.stavalues1::text AS sv1, s.stavalues2::text AS sv2,
+    s.stavalues3::text AS sv3, s.stavalues4::text AS sv4,
+    s.stavalues5::text AS sv5, 'is_odd_clone' AS direction
+FROM pg_statistic s
+JOIN pg_attribute a ON a.attrelid = s.starelid AND a.attnum = s.staattnum
+WHERE s.starelid = 'stats_export_import.is_odd'::regclass;
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 93b0bc2bc6..153d0dc6ac 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -29123,6 +29123,128 @@ postgres=# SELECT '0/0'::pg_lsn + pd.segment_number * ps.setting::int + :offset
     in identifying the specific disk files associated with database objects.
    </para>
 
+   <table id="functions-admin-statsimport">
+    <title>Database Object Statistics Import Functions</title>
+    <tgroup cols="1">
+     <thead>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        Function
+       </para>
+       <para>
+        Description
+       </para></entry>
+      </row>
+     </thead>
+
+     <tbody>
+      <row>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_relation_stats</primary>
+        </indexterm>
+        <function>pg_set_relation_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>,
+         <parameter>relpages</parameter> <type>integer</type>,
+         <parameter>reltuples</parameter> <type>real</type>,
+         <parameter>relallvisible</parameter> <type>integer</type> )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Updates the <structname>pg_class</structname> row for the specified
+        <parameter>relation</parameter>, setting the values for the columns
+        <structfield>reltuples</structfield>,
+        <structfield>relpages</structfield>, and
+        <structfield>relallvisible</structfield>.
+        To avoid table bloat in <structname>pg_class</structname>, this change
+        is made with an in-place update, and therefore cannot be rolled back
+        through normal transaction processing.
+       </para>
+       <para>
+        This function mimics the behavior of <command>ANALYZE</command> in its
+        effects on the values in <structname>pg_class</structname>, except that
+        the values are supplied as parameters rather than derived from table
+        sampling.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       <para>
+        The parameters supplied must all be NOT NULL. The value of
+        <structfield>relpages</structfield> must not be less than 0.  The
+        value of <structfield>reltuples</structfield> must not be less than
+        -1.0.  The value of <structfield>relallvisible</structfield> must not
+        be less than 0.
+       </para>
+       </entry>
+       <entry role="func_table_entry"><para role="func_signature">
+        <indexterm>
+         <primary>pg_set_attribute_stats</primary>
+        </indexterm>
+        <function>pg_set_attribute_stats</function> (
+         <parameter>relation</parameter> <type>regclass</type>
+         , <parameter>attname</parameter> <type>name</type>
+         , <parameter>inherited</parameter> <type>boolean</type>
+         , <parameter>null_frac</parameter> <type>real</type>
+         , <parameter>avg_width</parameter> <type>integer</type>
+         , <parameter>n_distinct</parameter> <type>real</type>
+         [, <parameter>most_common_vals</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>histogram_bounds</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>correlation</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elems</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>most_common_elem_freqs</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>elem_count_histogram</parameter> <type>real[]</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_length_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_empty_frac</parameter> <type>real</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ]
+         [, <parameter>range_bounds_histogram</parameter> <type>text</type>
+         <literal>DEFAULT</literal> <literal>NULL</literal> ] )
+        <returnvalue>void</returnvalue>
+       </para>
+       <para>
+        Replaces the <structname>pg_statistic</structname> row for the
+        <structname>pg_attribute</structname> row specified by
+        <parameter>relation</parameter>, <parameter>attname</parameter>
+        and <parameter>inherited</parameter>. The remaining parameters
+        all correspond to attributes of the same name found in
+        <link linkend="view-pg-stats"><structname>pg_stats</structname></link>,
+        and the values supplied in the parameter must meet the requirements of
+        the corresponding attribute.
+       </para>
+       <para>
+        This function mimics the behavior of <command>ANALYZE</command> in its
+        effects on the values in <structname>pg_statistic</structname>, except
+        that the values are supplied as parameters rather than derived from
+        table sampling.
+       </para>
+       <para>
+        The purpose of this function is to apply statistics values in an
+        upgrade situation that are "good enough" for system operation until
+        they are replaced by the next <command>ANALYZE</command>, usually via
+        <command>autovacuum</command> This function is used by
+        <command>pg_upgrade</command> and <command>pg_restore</command> to
+        convey the statistics from the old system version into the new one.
+       </para>
+       <para>
+        The caller must either be the owner of the relation, or have superuser
+        privileges.
+       </para>
+       </entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
    <table id="functions-admin-dblocation">
     <title>Database Object Location Functions</title>
     <tgroup cols="1">
-- 
2.44.0

From b86fa7d7c3c031c7dd5f7b42e34ff4689b7ac62b Mon Sep 17 00:00:00 2001
From: Corey Huinker <corey.huinker@gmail.com>
Date: Sat, 16 Mar 2024 17:21:10 -0400
Subject: [PATCH v15 2/2] Enable dumping of table/index stats in pg_dump.

For each table/matview/index dumped, it will generate a statement that
calls pg_set_relation_stats(), and it will generate a series of
statements that call pg_set_attribute_stats(), one per attribute. These
statements will restore the statistics of the current system onto the
destination system.

As is the pattern with pg_dump options, this can be disabled with
--no-statistics.
---
 src/bin/pg_dump/pg_backup.h            |   2 +
 src/bin/pg_dump/pg_backup_archiver.c   |   5 +
 src/bin/pg_dump/pg_dump.c              | 289 ++++++++++++++++++++++++-
 src/bin/pg_dump/pg_dump.h              |   1 +
 src/bin/pg_dump/pg_dumpall.c           |   5 +
 src/bin/pg_dump/pg_restore.c           |   3 +
 src/bin/pg_upgrade/t/002_pg_upgrade.pl |   4 +-
 7 files changed, 305 insertions(+), 4 deletions(-)

diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h
index 9ef2f2017e..1db5cf52eb 100644
--- a/src/bin/pg_dump/pg_backup.h
+++ b/src/bin/pg_dump/pg_backup.h
@@ -112,6 +112,7 @@ typedef struct _restoreOptions
 	int			no_publications;	/* Skip publication entries */
 	int			no_security_labels; /* Skip security label entries */
 	int			no_subscriptions;	/* Skip subscription entries */
+	int			no_statistics;		/* Skip statistics import */
 	int			strict_names;
 
 	const char *filename;
@@ -179,6 +180,7 @@ typedef struct _dumpOptions
 	int			no_security_labels;
 	int			no_publications;
 	int			no_subscriptions;
+	int			no_statistics;
 	int			no_toast_compression;
 	int			no_unlogged_table_data;
 	int			serializable_deferrable;
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index d97ebaff5b..d5f61399d9 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2833,6 +2833,10 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
 		return 0;
 
+	/* If it's a stats dump, maybe ignore it */
+	if (ropt->no_statistics && strcmp(te->desc, "STATISTICS") == 0)
+		return 0;
+
 	/* Ignore it if section is not to be dumped/restored */
 	switch (curSection)
 	{
@@ -2862,6 +2866,7 @@ _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
 	 */
 	if (strcmp(te->desc, "ACL") == 0 ||
 		strcmp(te->desc, "COMMENT") == 0 ||
+		strcmp(te->desc, "STATISTICS") == 0 ||
 		strcmp(te->desc, "SECURITY LABEL") == 0)
 	{
 		/* Database properties react to createDB, not selectivity options. */
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index b1c4c3ec7f..f7ba76217c 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -428,6 +428,7 @@ main(int argc, char **argv)
 		{"no-comments", no_argument, &dopt.no_comments, 1},
 		{"no-publications", no_argument, &dopt.no_publications, 1},
 		{"no-security-labels", no_argument, &dopt.no_security_labels, 1},
+		{"no-statistics", no_argument, &dopt.no_statistics, 1},
 		{"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
 		{"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
@@ -1144,6 +1145,7 @@ help(const char *progname)
 	printf(_("  --no-comments                do not dump comments\n"));
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
 	printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
@@ -7001,6 +7003,7 @@ getTables(Archive *fout, int *numTables)
 
 		/* Tables have data */
 		tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
+		tblinfo[i].dobj.components |= DUMP_COMPONENT_STATISTICS;
 
 		/* Mark whether table has an ACL */
 		if (!PQgetisnull(res, i, i_relacl))
@@ -7498,6 +7501,7 @@ getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
 			indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
 			indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
 			AssignDumpId(&indxinfo[j].dobj);
+			indxinfo[j].dobj.components |= DUMP_COMPONENT_STATISTICS;
 			indxinfo[j].dobj.dump = tbinfo->dobj.dump;
 			indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
 			indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
@@ -10247,6 +10251,272 @@ dumpComment(Archive *fout, const char *type,
 						catalogId, subid, dumpId, NULL);
 }
 
+/*
+ * Tabular description of the parameters to pg_set_relation_stats()
+ * required, param_name, param_type
+ */
+static const char *rel_stats_arginfo[][3] = {
+	{"t", "relation", "regclass"},
+	{"t", "relpages", "integer"},
+	{"t", "reltuples", "real"},
+	{"t", "relallvisible", "integer"},
+};
+
+/*
+ * Tabular description of the parameters to pg_set_attribute_stats()
+ * required, param_name, param_type
+ */
+static const char *att_stats_arginfo[][3] = {
+	{"t", "relation", "regclass"},
+	{"t", "attname", "name"},
+	{"t", "inherited", "boolean"},
+	{"t", "null_frac", "float4"},
+	{"t", "avg_width", "integer"},
+	{"t", "n_distinct", "float4"},
+	{"f", "most_common_vals", "text"},
+	{"f", "most_common_freqs", "float4[]"},
+	{"f", "histogram_bounds", "text"},
+	{"f", "correlation", "float4"},
+	{"f", "most_common_elems", "text"},
+	{"f", "most_common_elem_freqs", "float4[]"},
+	{"f", "elem_count_histogram", "float4[]"},
+	{"f", "range_length_histogram", "text"},
+	{"f", "range_empty_frac", "float4"},
+	{"f", "range_bounds_histogram", "text"},
+};
+
+/*
+ * getRelStatsExportQuery --
+ *
+ * Generate a query that will fetch all relation (e.g. pg_class)
+ * stats for a given relation.
+ */
+static void
+getRelStatsExportQuery(PQExpBuffer query, Archive *fout,
+					   const char *schemaname, const char *relname)
+{
+	resetPQExpBuffer(query);
+	appendPQExpBufferStr(query,
+						 "SELECT c.oid::regclass AS relation, c.relpages, "
+						 "c.reltuples, c.relallvisible "
+						 "FROM pg_class c "
+						 "JOIN pg_namespace n "
+						 "ON n.oid = c.relnamespace "
+						 "WHERE n.nspname = ");
+	appendStringLiteralAH(query, schemaname, fout);
+	appendPQExpBufferStr(query, " AND c.relname = ");
+	appendStringLiteralAH(query, relname, fout);
+}
+
+/*
+ * getAttStatsExportQuery --
+ *
+ * Generate a query that will fetch all attribute (e.g. pg_statistic)
+ * stats for a given relation.
+ */
+static void
+getAttStatsExportQuery(PQExpBuffer query, Archive *fout,
+					   const char *schemaname, const char *relname)
+{
+	resetPQExpBuffer(query);
+	appendPQExpBufferStr(query,
+						 "SELECT c.oid::regclass AS relation, "
+						 "s.attname,"
+						 "s.inherited,"
+						 "s.null_frac,"
+						 "s.avg_width,"
+						 "s.n_distinct,"
+						 "s.most_common_vals,"
+						 "s.most_common_freqs,"
+						 "s.histogram_bounds,"
+						 "s.correlation,"
+						 "s.most_common_elems,"
+						 "s.most_common_elem_freqs,"
+						 "s.elem_count_histogram,");
+
+	if (fout->remoteVersion >= 170000)
+		appendPQExpBufferStr(query,
+							 "s.range_length_histogram,"
+							 "s.range_empty_frac,"
+							 "s.range_bounds_histogram ");
+	else
+		appendPQExpBufferStr(query,
+							 "NULL AS range_length_histogram,"
+							 "NULL AS range_empty_frac,"
+							 "NULL AS range_bounds_histogram ");
+
+	appendPQExpBufferStr(query,
+						 "FROM pg_stats s "
+						 "JOIN pg_namespace n "
+						 "ON n.nspname = s.schemaname "
+						 "JOIN pg_class c "
+						 "ON c.relname = s.tablename "
+						 "AND c.relnamespace = n.oid "
+						 "WHERE s.schemaname = ");
+	appendStringLiteralAH(query, schemaname, fout);
+	appendPQExpBufferStr(query, " AND s.tablename = ");
+	appendStringLiteralAH(query, relname, fout);
+	appendPQExpBufferStr(query, " ORDER BY s.attname, s.inherited");
+}
+
+
+/*
+ * appendNamedArgument --
+ *
+ * Convenience routine for constructing parameters of the form:
+ *  paraname => 'value'::type
+ */
+static void
+appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname,
+					const char *argval, const char *argtype)
+{
+	appendPQExpBuffer(out, "\t%s => ", argname);
+	appendStringLiteralAH(out, argval, fout);
+	appendPQExpBuffer(out, "::%s", argtype);
+}
+
+/*
+ * appendRelStatsImport --
+ *
+ * Append a formatted pg_set_relation_stats statement.
+ */
+static void
+appendRelStatsImport(PQExpBuffer out, Archive *fout, PGresult *res)
+{
+	const char *sep = "";
+
+	if (PQntuples(res) == 0)
+		return;
+
+	appendPQExpBufferStr(out, "SELECT pg_catalog.pg_set_relation_stats(\n");
+
+	for (int argno = 0; argno < lengthof(rel_stats_arginfo); argno++)
+	{
+		bool			required = (rel_stats_arginfo[argno][0][0] == 't');
+		const char	   *argname = rel_stats_arginfo[argno][1];
+		const char	   *argtype = rel_stats_arginfo[argno][2];
+		int				fieldno = PQfnumber(res, argname);
+
+		if (fieldno < 0)
+			pg_fatal("relation stats export query missing field '%s'",
+					 argname);
+
+		if (PQgetisnull(res, 0, fieldno))
+		{
+			if (required)
+				pg_fatal("relation stats export query unexpected NULL in '%s'",
+						 argname);
+			else
+				continue;
+		}
+
+		appendPQExpBufferStr(out, sep);
+		appendNamedArgument(out, fout, argname, 
+							PQgetvalue(res, 0, fieldno), argtype);
+
+		sep = ",\n";
+	}
+	appendPQExpBufferStr(out, "\n);\n");
+}
+
+/*
+ * appendAttStatsImport --
+ *
+ * Append a series of formatted pg_set_attribute_stats statements.
+ */
+static void
+appendAttStatsImport(PQExpBuffer out, Archive *fout, PGresult *res)
+{
+	for (int rownum = 0; rownum < PQntuples(res); rownum++)
+	{
+		const char *sep = "";
+		appendPQExpBufferStr(out, "SELECT pg_catalog.pg_set_attribute_stats(\n");
+		for (int argno = 0; argno < lengthof(att_stats_arginfo); argno++)
+		{
+			bool		required = (att_stats_arginfo[argno][0][0] == 't');
+			const char	*argname = att_stats_arginfo[argno][1];
+			const char	*argtype = att_stats_arginfo[argno][2];
+			int			 fieldno = PQfnumber(res, argname);
+
+			if (fieldno < 0)
+				pg_fatal("attribute stats export query missing field '%s'",
+						 argname);
+
+			if (PQgetisnull(res, rownum, fieldno))
+			{
+				if (required)
+					pg_fatal("attribute stats export query unexpected NULL in '%s'",
+							 argname);
+				else
+					continue;
+			}
+
+			appendPQExpBufferStr(out, sep);
+			appendNamedArgument(out, fout, argname,
+								PQgetvalue(res, rownum, fieldno), argtype);
+			sep = ",\n";
+		}
+		appendPQExpBufferStr(out, "\n);\n");
+	}
+}
+
+/*
+ * dumpRelationStats --
+ *
+ * Dump command to import stats into the relation on the new database.
+ */
+static void
+dumpRelationStats(Archive *fout, const DumpableObject *dobj,
+				  const char *reltypename, DumpId dumpid)
+{
+	PGresult   *res;
+	PQExpBuffer query;
+	PQExpBuffer out;
+	PQExpBuffer tag;
+
+	/* do nothing, if --no-statistics is supplied */
+	if (fout->dopt->no_statistics)
+		return;
+
+	tag = createPQExpBuffer();
+	appendPQExpBuffer(tag, "%s %s", reltypename, fmtId(dobj->name));
+
+
+	query = createPQExpBuffer();
+	out = createPQExpBuffer();
+
+	getRelStatsExportQuery(query, fout, dobj->namespace->dobj.name,
+						   dobj->name);
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+	appendRelStatsImport(out, fout, res);
+	PQclear(res);
+
+	getRelStatsExportQuery(query, fout, dobj->namespace->dobj.name,
+						   dobj->name);
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+	appendRelStatsImport(out, fout, res);
+	PQclear(res);
+
+	getAttStatsExportQuery(query, fout, dobj->namespace->dobj.name,
+							  dobj->name);
+	res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
+	appendAttStatsImport(out, fout, res);
+	PQclear(res);
+
+	ArchiveEntry(fout, nilCatalogId, createDumpId(),
+				 ARCHIVE_OPTS(.tag = tag->data,
+							  .namespace = dobj->namespace->dobj.name,
+							  .description = "STATISTICS DATA",
+							  .section = SECTION_NONE,
+							  .createStmt = out->data,
+							  .deps = &dumpid,
+							  .nDeps = 1));
+
+	destroyPQExpBuffer(query);
+	destroyPQExpBuffer(out);
+	destroyPQExpBuffer(tag);
+}
+
 /*
  * dumpTableComment --
  *
@@ -16681,6 +16951,13 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
 	if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
 		dumpTableSecLabel(fout, tbinfo, reltypename);
 
+	/* Statistics are dependent on the definition, not the data */
+	/* Views don't have stats */
+	if ((tbinfo->dobj.dump & DUMP_COMPONENT_STATISTICS) &&
+		(tbinfo->relkind != RELKIND_VIEW))
+		dumpRelationStats(fout, &tbinfo->dobj, reltypename,
+						  tbinfo->dobj.dumpId);
+
 	/* Dump comments on inlined table constraints */
 	for (j = 0; j < tbinfo->ncheck; j++)
 	{
@@ -16882,6 +17159,7 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 	PQExpBuffer delq;
 	char	   *qindxname;
 	char	   *qqindxname;
+	DumpId		dumpid;
 
 	/* Do nothing in data-only dump */
 	if (dopt->dataOnly)
@@ -16994,14 +17272,21 @@ dumpIndex(Archive *fout, const IndxInfo *indxinfo)
 		free(indstatvalsarray);
 	}
 
+	/* Comments and stats share same .dep */
+	dumpid = is_constraint ? indxinfo->indexconstraint :
+		indxinfo->dobj.dumpId;
+
 	/* Dump Index Comments */
 	if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
 		dumpComment(fout, "INDEX", qindxname,
 					tbinfo->dobj.namespace->dobj.name,
 					tbinfo->rolname,
 					indxinfo->dobj.catId, 0,
-					is_constraint ? indxinfo->indexconstraint :
-					indxinfo->dobj.dumpId);
+					dumpid);
+
+	/* Dump Index Stats */
+	if (indxinfo->dobj.dump & DUMP_COMPONENT_STATISTICS)
+		dumpRelationStats(fout, &indxinfo->dobj, "INDEX", dumpid);
 
 	destroyPQExpBuffer(q);
 	destroyPQExpBuffer(delq);
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 9bc93520b4..d6a071ec28 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -101,6 +101,7 @@ typedef uint32 DumpComponents;
 #define DUMP_COMPONENT_ACL			(1 << 4)
 #define DUMP_COMPONENT_POLICY		(1 << 5)
 #define DUMP_COMPONENT_USERMAP		(1 << 6)
+#define DUMP_COMPONENT_STATISTICS	(1 << 7)
 #define DUMP_COMPONENT_ALL			(0xFFFF)
 
 /*
diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
index 046c0dc3b3..69652aa205 100644
--- a/src/bin/pg_dump/pg_dumpall.c
+++ b/src/bin/pg_dump/pg_dumpall.c
@@ -105,6 +105,7 @@ static int	use_setsessauth = 0;
 static int	no_comments = 0;
 static int	no_publications = 0;
 static int	no_security_labels = 0;
+static int	no_statistics = 0;
 static int	no_subscriptions = 0;
 static int	no_toast_compression = 0;
 static int	no_unlogged_table_data = 0;
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
 		{"no-role-passwords", no_argument, &no_role_passwords, 1},
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
+		{"no-statistics", no_argument, &no_statistics, 1},
 		{"no-sync", no_argument, NULL, 4},
 		{"no-toast-compression", no_argument, &no_toast_compression, 1},
 		{"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
@@ -453,6 +455,8 @@ main(int argc, char *argv[])
 		appendPQExpBufferStr(pgdumpopts, " --no-publications");
 	if (no_security_labels)
 		appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
+	if (no_statistics)
+		appendPQExpBufferStr(pgdumpopts, " --no-statistics");
 	if (no_subscriptions)
 		appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
 	if (no_toast_compression)
@@ -668,6 +672,7 @@ help(void)
 	printf(_("  --no-publications            do not dump publications\n"));
 	printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
 	printf(_("  --no-security-labels         do not dump security label assignments\n"));
+	printf(_("  --no-statistics              do not dump statistics\n"));
 	printf(_("  --no-subscriptions           do not dump subscriptions\n"));
 	printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
 	printf(_("  --no-table-access-method     do not dump table access methods\n"));
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
index c3beacdec1..2d326dec72 100644
--- a/src/bin/pg_dump/pg_restore.c
+++ b/src/bin/pg_dump/pg_restore.c
@@ -75,6 +75,7 @@ main(int argc, char **argv)
 	static int	no_publications = 0;
 	static int	no_security_labels = 0;
 	static int	no_subscriptions = 0;
+	static int  no_statistics = 0;
 	static int	strict_names = 0;
 
 	struct option cmdopts[] = {
@@ -126,6 +127,7 @@ main(int argc, char **argv)
 		{"no-security-labels", no_argument, &no_security_labels, 1},
 		{"no-subscriptions", no_argument, &no_subscriptions, 1},
 		{"filter", required_argument, NULL, 4},
+		{"no-statistics", no_argument, &no_statistics, 1},
 
 		{NULL, 0, NULL, 0}
 	};
@@ -358,6 +360,7 @@ main(int argc, char **argv)
 	opts->no_publications = no_publications;
 	opts->no_security_labels = no_security_labels;
 	opts->no_subscriptions = no_subscriptions;
+	opts->no_statistics = no_statistics;
 
 	if (if_exists && !opts->dropSchema)
 		pg_fatal("option --if-exists requires option -c/--clean");
diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
index 3e67121a8d..5006223fbe 100644
--- a/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
@@ -315,7 +315,7 @@ if (defined($ENV{oldinstall}))
 # that we need to use pg_dumpall from the new node here.
 my @dump_command = (
 	'pg_dumpall', '--no-sync', '-d', $oldnode->connstr('postgres'),
-	'-f', $dump1_file);
+	'-f', $dump1_file, '--no-statistics');
 # --extra-float-digits is needed when upgrading from a version older than 11.
 push(@dump_command, '--extra-float-digits', '0')
   if ($oldnode->pg_version < 12);
@@ -483,7 +483,7 @@ is( $result,
 # Second dump from the upgraded instance.
 @dump_command = (
 	'pg_dumpall', '--no-sync', '-d', $newnode->connstr('postgres'),
-	'-f', $dump2_file);
+	'-f', $dump2_file, '--no-statistics');
 # --extra-float-digits is needed when upgrading from a version older than 11.
 push(@dump_command, '--extra-float-digits', '0')
   if ($oldnode->pg_version < 12);
-- 
2.44.0