| blob | 8f73a5df9568b8706cd20b72925e49190c5d72e6 |
1 /*-------------------------------------------------------------------------
2 *
3 * pg_dump.c
4 * pg_dump is a utility for dumping out a postgres database
5 * into a script file.
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * pg_dump will read the system catalogs in a database and dump out a
11 * script that reproduces the schema in terms of SQL that is understood
12 * by PostgreSQL
13 *
14 * Note that pg_dump runs in a transaction-snapshot mode transaction,
15 * so it sees a consistent snapshot of the database including system
16 * catalogs. However, it relies in part on various specialized backend
17 * functions like pg_get_indexdef(), and those things tend to look at
18 * the currently committed state. So it is possible to get 'cache
19 * lookup failed' error if someone performs DDL changes while a dump is
20 * happening. The window for this sort of thing is from the acquisition
21 * of the transaction snapshot to getSchemaData() (when pg_dump acquires
22 * AccessShareLock on every table it intends to dump). It isn't very large,
23 * but it can happen.
24 *
25 * http://archives.postgresql.org/pgsql-bugs/2010-02/msg00187.php
26 *
27 * IDENTIFICATION
28 * src/bin/pg_dump/pg_dump.c
29 *
30 *-------------------------------------------------------------------------
31 */
34 #include <unistd.h>
35 #include <ctype.h>
36 #include <limits.h>
37 #ifdef HAVE_TERMIOS_H
38 #include <termios.h>
39 #endif
72 {
78 {
86 {
95 {
105 /* sequence types */
107 {
108 SEQTYPE_SMALLINT,
109 SEQTYPE_INTEGER,
110 SEQTYPE_BIGINT,
114 {
118 };
124 {
138 {
144 /* global decls */
149 /* The specified names/patterns should to match at least one entity */
154 /*
155 * Object inclusion/exclusion lists
156 *
157 * The string lists record the patterns given by command-line switches,
158 * which we then convert to lists of OIDs of matching objects.
159 */
186 /* override for standard extra_float_digits setting */
190 /* sorted table of role names */
194 /* sorted table of comments */
198 /* sorted table of security labels */
202 /* sorted table of pg_class information for binary upgrade */
206 /* sorted table of sequences */
210 /*
211 * The default number of rows per INSERT when
212 * --inserts is specified without --rows-per-insert
213 */
214 #define DUMP_DEFAULT_ROWS_PER_INSERT 1
216 /*
217 * Maximum number of large objects to group into a single ArchiveEntry.
218 * At some point we might want to make this user-controllable, but for now
219 * a hard-wired setting will suffice.
220 */
221 #define MAX_BLOBS_PER_ARCHIVE_ENTRY 1000
223 /*
224 * Macro for producing quoted, schema-qualified name of a dumpable object.
225 */
226 #define fmtQualifiedDumpable(obj) \
227 fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
228 (obj)->dobj.name)
373 PQExpBuffer upgrade_buffer,
374 Oid pg_type_oid,
378 PQExpBuffer upgrade_buffer,
382 PQExpBuffer upgrade_buffer,
383 Oid pg_class_oid);
402 int
404 {
424 ArchiveMode archiveMode;
470 /*
471 * the following options don't have an equivalent short option letter
472 */
512 };
518 /*
519 * Initialize what we need for parallel execution, especially for thread
520 * support on Windows.
521 */
527 {
529 {
532 }
534 {
537 }
538 }
544 {
546 {
594 PG_MAX_JOBS,
617 /* no-op, still accepted for backwards compatibility */
665 /* This covers the long options. */
701 /*
702 * dump_inserts also stores --rows-per-insert, careful not to
703 * overwrite that.
704 */
717 optarg);
722 optarg);
728 optarg);
733 optarg);
747 optarg);
751 /* getopt_long already emitted a complaint */
754 }
755 }
757 /*
758 * Non-option argument specifies database name as long as it wasn't
759 * already specified with -d / --dbname
760 */
764 /* Complain if any arguments remain */
766 {
771 }
773 /* --column-inserts implies --inserts */
777 /*
778 * Binary upgrade mode implies dumping sequence data even in schema-only
779 * mode. This is not exposed as a separate option, but kept separate
780 * internally for clarity.
781 */
800 /* set derivative flags */
804 /*
805 * --inserts are already implied above if --column-inserts or
806 * --rows-per-insert were specified.
807 */
809 pg_fatal("option --on-conflict-do-nothing requires option --inserts, --rows-per-insert, or --column-inserts");
811 /* Identify archive format to emit */
814 /* archiveFormat specific setup */
818 /*
819 * Custom and directory formats are compressed by default with gzip when
820 * available, not the others. If gzip is not available, no compression is
821 * done by default.
822 */
825 {
826 #ifdef HAVE_LIBZ
828 #else
830 #endif
831 }
833 /*
834 * Compression options
835 */
839 compression_algorithm_str);
846 error_detail);
852 /*
853 * Disable support for zstd workers for now - these are based on
854 * threading, and it's unclear how it interacts with parallel dumps on
855 * platforms where that relies on threads too (e.g. Windows).
856 */
861 /*
862 * If emitting an archive format, we always want to emit a DATABASE item,
863 * in case --create is specified at pg_restore time.
864 */
868 /* Parallel backup only in the directory archive format so far */
872 /* Open the output file */
876 /* Make dump options accessible right away */
879 /* Register the cleanup hook */
882 /* Let the archiver know how noisy to be */
886 /*
887 * We allow the server to be back to 9.2, and up to any minor release of
888 * our own major version. (See also version check in pg_dumpall.c.)
889 */
895 /*
896 * Open the database using the Archiver, so it knows about it. Errors mean
897 * death.
898 */
902 /*
903 * On hot standbys, never try to dump unlogged table data, since it will
904 * just throw an error.
905 */
909 /*
910 * Find the last built-in OID, if needed (prior to 8.1)
911 *
912 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
913 */
918 /* Expand schema selection patterns into OID lists */
920 {
923 strict_names);
926 }
930 /* non-matching exclusion patterns aren't an error */
932 /* Expand table selection patterns into OID lists */
961 /* non-matching exclusion patterns aren't an error */
963 /* Expand extension selection patterns into OID lists */
965 {
968 strict_names);
971 }
975 /* non-matching exclusion patterns aren't an error */
977 /*
978 * Dumping LOs is the default for dumps where an inclusion switch is not
979 * used (an "include everything" dump). -B can be used to exclude LOs
980 * from those dumps. -b can be used to include LOs even when an inclusion
981 * switch is used.
982 *
983 * -s means "schema only" and LOs are data, not schema, so we never
984 * include LOs when -s is used.
985 */
989 /*
990 * Collect role names so we can map object owner OIDs to names.
991 */
994 /*
995 * Now scan the database and create DumpableObject structs for all the
996 * objects we intend to dump.
997 */
1001 {
1006 }
1011 /*
1012 * In binary-upgrade mode, we do not have to worry about the actual LO
1013 * data or the associated metadata that resides in the pg_largeobject and
1014 * pg_largeobject_metadata tables, respectively.
1015 *
1016 * However, we do need to collect LO information as there may be comments
1017 * or other information on LOs that we do need to dump out.
1018 */
1022 /*
1023 * Collect dependency data to assist in ordering the objects.
1024 */
1027 /*
1028 * Collect ACLs, comments, and security labels, if wanted.
1029 */
1037 /* For binary upgrade mode, collect required pg_class information. */
1041 /* Collect sequence information. */
1044 /* Lastly, create dummy objects to represent the section boundaries */
1047 /* Get pointers to all the known DumpableObjects */
1050 /*
1051 * Add dummy dependencies to enforce the dump section ordering.
1052 */
1055 /*
1056 * Sort the objects into a safe dump order (no forward references).
1057 *
1058 * We rely on dependency information to help us determine a safe order, so
1059 * the initial sort is mostly for cosmetic purposes: we sort by name to
1060 * ensure that logically identical schemas will dump identically.
1061 */
1067 /*
1068 * Create archive TOC entries for all the objects to be dumped, in a safe
1069 * order.
1070 */
1072 /*
1073 * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
1074 */
1079 /* The database items are always next, unless we don't want them at all */
1083 /* Now the rearrangeable objects. */
1087 /*
1088 * Set up options info to ensure we dump what we want.
1089 */
1093 /* if you change this list, see dumpOptionsFromRestoreOptions */
1131 /* Mark which entries should be output */
1134 /*
1135 * The archive's TOC entries are now marked as to which ones will actually
1136 * be output, so we can set up their dependency lists properly. This isn't
1137 * necessary for plain-text output, though.
1138 */
1142 /*
1143 * And finally we can do the actual output.
1144 *
1145 * Note: for non-plain-text output formats, the output file is written
1146 * inside CloseArchive(). This is, um, bizarre; but not worth changing
1147 * right now.
1148 */
1155 }
1158 static void
1160 {
1256 }
1258 static void
1261 {
1268 /*
1269 * Set the client encoding if requested.
1270 */
1272 {
1275 dumpencoding);
1276 }
1278 /*
1279 * Get the active encoding and the standard_conforming_strings setting, so
1280 * we know how to escape strings.
1281 */
1287 /*
1288 * Set the role if requested. In a parallel dump worker, we'll be passed
1289 * use_role == NULL, but AH->use_role is already set (if user specified it
1290 * originally) and we should use that.
1291 */
1295 /* Set the role if requested */
1297 {
1304 /* save it for possible later use by parallel workers */
1307 }
1309 /* Set the datestyle to ISO to ensure the dump's portability */
1312 /* Likewise, avoid using sql_standard intervalstyle */
1315 /*
1316 * Use an explicitly specified extra_float_digits if it has been provided.
1317 * Otherwise, set extra_float_digits so that we can dump float data
1318 * exactly (given correctly implemented float I/O code, anyway).
1319 */
1321 {
1325 extra_float_digits);
1328 }
1329 else
1332 /*
1333 * Disable synchronized scanning, to prevent unpredictable changes in row
1334 * ordering across a dump and reload.
1335 */
1338 /*
1339 * Disable timeouts if supported.
1340 */
1349 /*
1350 * Quote all identifiers, if requested.
1351 */
1355 /*
1356 * Adjust row-security mode, if supported.
1357 */
1359 {
1362 else
1364 }
1366 /*
1367 * For security reasons, we restrict the expansion of non-system views and
1368 * access to foreign tables during the pg_dump process. This restriction
1369 * is adjusted when dumping foreign table data.
1370 */
1373 /*
1374 * Initialize prepared-query state to "nothing prepared". We do this here
1375 * so that a parallel dump worker will have its own state.
1376 */
1379 /*
1380 * Start transaction-snapshot mode transaction to dump consistent data.
1381 */
1384 /*
1385 * To support the combination of serializable_deferrable with the jobs
1386 * option we use REPEATABLE READ for the worker connections that are
1387 * passed a snapshot. As long as the snapshot is acquired in a
1388 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1389 * REPEATABLE READ transaction provides the appropriate integrity
1390 * guarantees. This is a kluge, but safe for back-patching.
1391 */
1394 "SET TRANSACTION ISOLATION LEVEL "
1396 else
1398 "SET TRANSACTION ISOLATION LEVEL "
1401 /*
1402 * If user specified a snapshot to use, select that. In a parallel dump
1403 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1404 * is already set (if the server can handle it) and we should use that.
1405 */
1410 {
1417 }
1419 {
1423 }
1424 }
1426 /* Set up connection for a parallel worker process */
1427 static void
1429 {
1430 /*
1431 * We want to re-select all the same values the leader connection is
1432 * using. We'll have inherited directly-usable values in
1433 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1434 * inherited encoding value back to a string to pass to setup_connection.
1435 */
1438 NULL,
1439 NULL);
1440 }
1444 {
1454 }
1456 static ArchiveFormat
1458 {
1459 ArchiveFormat archiveFormat;
1464 {
1465 /* This is used by pg_dumpall, and is not documented */
1468 }
1485 else
1488 }
1490 /*
1491 * Find the OIDs of all schemas matching the given list of patterns,
1492 * and append them to the given OID list.
1493 */
1494 static void
1499 {
1500 PQExpBuffer query;
1510 /*
1511 * The loop below runs multiple SELECTs might sometimes result in
1512 * duplicate entries in the OID list, but we don't care.
1513 */
1516 {
1517 PQExpBufferData dbbuf;
1538 {
1540 }
1544 }
1547 }
1549 /*
1550 * Find the OIDs of all extensions matching the given list of patterns,
1551 * and append them to the given OID list.
1552 */
1553 static void
1558 {
1559 PQExpBuffer query;
1569 /*
1570 * The loop below runs multiple SELECTs might sometimes result in
1571 * duplicate entries in the OID list, but we don't care.
1572 */
1574 {
1591 {
1593 }
1597 }
1600 }
1602 /*
1603 * Find the OIDs of all foreign servers matching the given list of patterns,
1604 * and append them to the given OID list.
1605 */
1606 static void
1610 {
1611 PQExpBuffer query;
1621 /*
1622 * The loop below runs multiple SELECTs might sometimes result in
1623 * duplicate entries in the OID list, but we don't care.
1624 */
1627 {
1648 }
1651 }
1653 /*
1654 * Find the OIDs of all tables matching the given list of patterns,
1655 * and append them to the given OID list. See also expand_dbname_patterns()
1656 * in pg_dumpall.c
1657 */
1658 static void
1662 {
1663 PQExpBuffer query;
1673 /*
1674 * this might sometimes result in duplicate entries in the OID list, but
1675 * we don't care.
1676 */
1679 {
1680 PQExpBufferData dbbuf;
1683 /*
1684 * Query must remain ABSOLUTELY devoid of unqualified names. This
1685 * would be unnecessary given a pg_table_is_visible() variant taking a
1686 * search_path argument.
1687 *
1688 * For with_child_tables, we start with the basic query's results and
1689 * recursively search the inheritance tree to add child tables.
1690 */
1692 {
1694 }
1697 "SELECT c.oid"
1705 RELKIND_PARTITIONED_TABLE);
1719 {
1727 }
1732 ALWAYS_SECURE_SEARCH_PATH_SQL));
1737 {
1739 }
1743 }
1746 }
1748 /*
1749 * Verifies that the connected database name matches the given database name,
1750 * and if not, dies with an error about the given pattern.
1751 *
1752 * The 'dbname' argument should be a literal name parsed from 'pattern'.
1753 */
1754 static void
1756 {
1765 pattern);
1766 }
1768 /*
1769 * checkExtensionMembership
1770 * Determine whether object is an extension member, and if so,
1771 * record an appropriate dependency and set the object's dump flag.
1772 *
1773 * It's important to call this for each object that could be an extension
1774 * member. Generally, we integrate this with determining the object's
1775 * to-be-dumped-ness, since extension membership overrides other rules for that.
1776 *
1777 * Returns true if object is an extension member, else false.
1778 */
1779 static bool
1781 {
1789 /* Record dependency so that getDependencies needn't deal with that */
1792 /*
1793 * In 9.6 and above, mark the member object to have any non-initial ACLs
1794 * dumped. (Any initial ACLs will be removed later, using data from
1795 * pg_init_privs, so that we'll dump only the delta from the extension's
1796 * initial setup.)
1797 *
1798 * Prior to 9.6, we do not include any extension member components.
1799 *
1800 * In binary upgrades, we still dump all components of the members
1801 * individually, since the idea is to exactly reproduce the database
1802 * contents rather than replace the extension contents with something
1803 * different.
1804 *
1805 * Note: it might be interesting someday to implement storage and delta
1806 * dumping of extension members' RLS policies and/or security labels.
1807 * However there is a pitfall for RLS policies: trying to dump them
1808 * requires getting a lock on their tables, and the calling user might not
1809 * have privileges for that. We need no lock to examine a table's ACLs,
1810 * so the current feature doesn't have a problem of that sort.
1811 */
1814 else
1815 {
1818 else
1820 }
1823 }
1825 /*
1826 * selectDumpableNamespace: policy-setting subroutine
1827 * Mark a namespace as to be dumped or not
1828 */
1829 static void
1831 {
1832 /*
1833 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
1834 * and (for --clean) a DROP SCHEMA statement. (In the absence of
1835 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
1836 */
1839 /*
1840 * If specific tables are being dumped, do not dump any complete
1841 * namespaces. If specific namespaces are being dumped, dump just those
1842 * namespaces. Otherwise, dump all non-system namespaces.
1843 */
1853 {
1854 /*
1855 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
1856 * they are interesting (and not the original ACLs which were set at
1857 * initdb time, see pg_init_privs).
1858 */
1860 }
1863 {
1864 /* Other system schemas don't get dumped */
1866 }
1868 {
1869 /*
1870 * The public schema is a strange beast that sits in a sort of
1871 * no-mans-land between being a system object and a user object.
1872 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
1873 * a comment and an indication of ownership. If the owner is the
1874 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
1875 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
1876 */
1883 /*
1884 * Also, make like it has a comment even if it doesn't; this is so
1885 * that we'll emit a command to drop the comment, if appropriate.
1886 * (Without this, we'd not call dumpCommentExtended for it.)
1887 */
1889 }
1890 else
1893 /*
1894 * In any case, a namespace can be excluded by an exclusion switch
1895 */
1901 /*
1902 * If the schema belongs to an extension, allow extension membership to
1903 * override the dump decision for the schema itself. However, this does
1904 * not change dump_contains, so this won't change what we do with objects
1905 * within the schema. (If they belong to the extension, they'll get
1906 * suppressed by it, otherwise not.)
1907 */
1909 }
1911 /*
1912 * selectDumpableTable: policy-setting subroutine
1913 * Mark a table as to be dumped or not
1914 */
1915 static void
1917 {
1921 /*
1922 * If specific tables are being dumped, dump just those tables; else, dump
1923 * according to the parent namespace's dump flag.
1924 */
1929 else
1932 /*
1933 * In any case, a table can be excluded by an exclusion switch
1934 */
1939 }
1941 /*
1942 * selectDumpableType: policy-setting subroutine
1943 * Mark a type as to be dumped or not
1944 *
1945 * If it's a table's rowtype or an autogenerated array type, we also apply a
1946 * special type code to facilitate sorting into the desired order. (We don't
1947 * want to consider those to be ordinary types because that would bring tables
1948 * up into the datatype part of the dump order.) We still set the object's
1949 * dump flag; that's not going to cause the dummy type to be dumped, but we
1950 * need it so that casts involving such types will be dumped correctly -- see
1951 * dumpCast. This means the flag should be set the same as for the underlying
1952 * object (the table or base type).
1953 */
1954 static void
1956 {
1957 /* skip complex types, except for standalone composite types */
1960 {
1966 else
1969 }
1971 /* skip auto-generated array and multirange types */
1973 {
1976 /*
1977 * Fall through to set the dump flag; we assume that the subsequent
1978 * rules will do the same thing as they would for the array's base
1979 * type or multirange's range type. (We cannot reliably look up the
1980 * base type here, since getTypes may not have processed it yet.)
1981 */
1982 }
1987 /* Dump based on if the contents of the namespace are being dumped */
1989 }
1991 /*
1992 * selectDumpableDefaultACL: policy-setting subroutine
1993 * Mark a default ACL as to be dumped or not
1994 *
1995 * For per-schema default ACLs, dump if the schema is to be dumped.
1996 * Otherwise dump if we are dumping "everything". Note that dumpSchema
1997 * and aclsSkip are checked separately.
1998 */
1999 static void
2001 {
2002 /* Default ACLs can't be extension members */
2005 /* default ACLs are considered part of the namespace */
2007 else
2010 }
2012 /*
2013 * selectDumpableCast: policy-setting subroutine
2014 * Mark a cast as to be dumped or not
2015 *
2016 * Casts do not belong to any particular namespace (since they haven't got
2017 * names), nor do they have identifiable owners. To distinguish user-defined
2018 * casts from built-in ones, we must resort to checking whether the cast's
2019 * OID is in the range reserved for initdb.
2020 */
2021 static void
2023 {
2027 /*
2028 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
2029 * support ACLs currently.
2030 */
2033 else
2036 }
2038 /*
2039 * selectDumpableProcLang: policy-setting subroutine
2040 * Mark a procedural language as to be dumped or not
2041 *
2042 * Procedural languages do not belong to any particular namespace. To
2043 * identify built-in languages, we must resort to checking whether the
2044 * language's OID is in the range reserved for initdb.
2045 */
2046 static void
2048 {
2052 /*
2053 * Only include procedural languages when we are dumping everything.
2054 *
2055 * For from-initdb procedural languages, only include ACLs, as we do for
2056 * the pg_catalog namespace. We need this because procedural languages do
2057 * not live in any namespace.
2058 */
2061 else
2062 {
2066 else
2068 }
2069 }
2071 /*
2072 * selectDumpableAccessMethod: policy-setting subroutine
2073 * Mark an access method as to be dumped or not
2074 *
2075 * Access methods do not belong to any particular namespace. To identify
2076 * built-in access methods, we must resort to checking whether the
2077 * method's OID is in the range reserved for initdb.
2078 */
2079 static void
2081 {
2085 /*
2086 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
2087 * they do not support ACLs currently.
2088 */
2091 else
2094 }
2096 /*
2097 * selectDumpableExtension: policy-setting subroutine
2098 * Mark an extension as to be dumped or not
2099 *
2100 * Built-in extensions should be skipped except for checking ACLs, since we
2101 * assume those will already be installed in the target database. We identify
2102 * such extensions by their having OIDs in the range reserved for initdb.
2103 * We dump all user-added extensions by default. No extensions are dumped
2104 * if include_everything is false (i.e., a --schema or --table switch was
2105 * given), except if --extension specifies a list of extensions to dump.
2106 */
2107 static void
2109 {
2110 /*
2111 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2112 * change permissions on their member objects, if they wish to, and have
2113 * those changes preserved.
2114 */
2117 else
2118 {
2119 /* check if there is a list of extensions to dump */
2125 else
2130 /* check that the extension is not explicitly excluded */
2135 }
2136 }
2138 /*
2139 * selectDumpablePublicationObject: policy-setting subroutine
2140 * Mark a publication object as to be dumped or not
2141 *
2142 * A publication can have schemas and tables which have schemas, but those are
2143 * ignored in decision making, because publications are only dumped when we are
2144 * dumping everything.
2145 */
2146 static void
2148 {
2154 }
2156 /*
2157 * selectDumpableStatisticsObject: policy-setting subroutine
2158 * Mark an extended statistics object as to be dumped or not
2159 *
2160 * We dump an extended statistics object if the schema it's in and the table
2161 * it's for are being dumped. (This'll need more thought if statistics
2162 * objects ever support cross-table stats.)
2163 */
2164 static void
2166 {
2174 }
2176 /*
2177 * selectDumpableObject: policy-setting subroutine
2178 * Mark a generic dumpable object as to be dumped or not
2179 *
2180 * Use this only for object types without a special-case routine above.
2181 */
2182 static void
2184 {
2188 /*
2189 * Default policy is to dump if parent namespace is dumpable, or for
2190 * non-namespace-associated items, dump if we're dumping "everything".
2191 */
2194 else
2197 }
2199 /*
2200 * Dump a table's contents for loading using the COPY command
2201 * - this routine is called by the Archiver when it wants the table
2202 * to be dumped.
2203 */
2204 static int
2206 {
2212 /*
2213 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2214 * which uses it already.
2215 */
2226 /*
2227 * Specify the column list explicitly so that we have no possibility of
2228 * retrieving data in the wrong column order. (The default column
2229 * ordering of COPY will not be what we want in certain corner cases
2230 * involving ADD COLUMN and inheritance.)
2231 */
2234 /*
2235 * Use COPY (SELECT ...) TO when dumping a foreign table's data, and when
2236 * a filter condition was specified. For other cases a simple COPY
2237 * suffices.
2238 */
2240 {
2241 /* Temporary allows to access to foreign tables to dump data */
2246 /* klugery to get rid of parens in column list */
2248 {
2251 }
2252 else
2258 }
2259 else
2260 {
2263 column_list);
2264 }
2270 {
2277 {
2280 }
2282 /* ----------
2283 * THROTTLE:
2284 *
2285 * There was considerable discussion in late July, 2000 regarding
2286 * slowing down pg_dump when backing up large tables. Users with both
2287 * slow & fast (multi-processor) machines experienced performance
2288 * degradation when doing a backup.
2289 *
2290 * Initial attempts based on sleeping for a number of ms for each ms
2291 * of work were deemed too complex, then a simple 'sleep in each loop'
2292 * implementation was suggested. The latter failed because the loop
2293 * was too tight. Finally, the following was implemented:
2294 *
2295 * If throttle is non-zero, then
2296 * See how long since the last sleep.
2297 * Work out how long to sleep (based on ratio).
2298 * If sleep is more than 100ms, then
2299 * sleep
2300 * reset timer
2301 * EndIf
2302 * EndIf
2303 *
2304 * where the throttle value was the number of ms to sleep per ms of
2305 * work. The calculation was done in each loop.
2306 *
2307 * Most of the hard work is done in the backend, and this solution
2308 * still did not work particularly well: on slow machines, the ratio
2309 * was 50:1, and on medium paced machines, 1:1, and on fast
2310 * multi-processor machines, it had little or no effect, for reasons
2311 * that were unclear.
2312 *
2313 * Further discussion ensued, and the proposal was dropped.
2314 *
2315 * For those people who want this feature, it can be implemented using
2316 * gettimeofday in each loop, calculating the time since last sleep,
2317 * multiplying that by the sleep ratio, then if the result is more
2318 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2319 * function to sleep for a subsecond period ie.
2320 *
2321 * select(0, NULL, NULL, NULL, &tvi);
2322 *
2323 * This will return after the interval specified in the structure tvi.
2324 * Finally, call gettimeofday again to save the 'last sleep time'.
2325 * ----------
2326 */
2327 }
2331 {
2332 /* copy data transfer failed */
2333 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2337 }
2339 /* Check command status and return to normal libpq state */
2342 {
2347 }
2350 /* Do this to ensure we've pumped libpq back to idle state */
2353 classname);
2357 /* Revert back the setting */
2362 }
2364 /*
2365 * Dump table data using INSERT commands.
2366 *
2367 * Caution: when we restore from an archive file direct to database, the
2368 * INSERT commands emitted by this function have to be parsed by
2369 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
2370 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
2371 */
2372 static int
2374 {
2383 i;
2387 /* Temporary allows to access to foreign tables to dump data */
2391 /*
2392 * If we're going to emit INSERTs with column names, the most efficient
2393 * way to deal with generated columns is to exclude them entirely. For
2394 * INSERTs without column names, we have to emit DEFAULT rather than the
2395 * actual column value --- but we can save a few cycles by fetching nulls
2396 * rather than the uninteresting-to-us value.
2397 */
2402 {
2411 else
2414 nfields++;
2415 }
2416 /* Servers before 9.4 will complain about zero-column SELECT */
2427 {
2429 PGRES_TUPLES_OK);
2431 /* cross-check field count, allowing for dummy NULL if any */
2437 /*
2438 * First time through, we build as much of the INSERT statement as
2439 * possible in "insertStmt", which we can then just print for each
2440 * statement. If the table happens to have zero dumpable columns then
2441 * this will be a complete statement, otherwise it will end in
2442 * "VALUES" and be ready to have the row's column values printed.
2443 */
2445 {
2450 /*
2451 * When load-via-partition-root is set or forced, get the root
2452 * table name for the partition table, so that we can reload data
2453 * through the root table.
2454 */
2459 else
2465 /* corner case for zero-column table */
2467 {
2469 }
2470 else
2471 {
2472 /* append the list of column names if required */
2474 {
2477 {
2482 }
2484 }
2490 }
2491 }
2494 {
2495 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2499 /*
2500 * If it is zero-column table then we've already written the
2501 * complete statement, which will mean we've disobeyed
2502 * --rows-per-insert when it's set greater than 1. We do support
2503 * a way to make this multi-row with: SELECT UNION ALL SELECT
2504 * UNION ALL ... but that's non-standard so we should avoid it
2505 * given that using INSERTs is mostly only ever needed for
2506 * cross-database exports.
2507 */
2511 /* Emit a row heading */
2516 else
2520 {
2524 {
2527 }
2529 {
2532 }
2534 /* XXX This code is partially duplicated in ruleutils.c */
2536 {
2544 {
2545 /*
2546 * These types are printed without quotes unless
2547 * they contain values that aren't accepted by the
2548 * scanner unquoted (e.g., 'NaN'). Note that
2549 * strtod() and friends might accept NaN, so we
2550 * can't use that to test.
2551 *
2552 * In reality we only need to defend against
2553 * infinity and NaN, so we need not get too crazy
2554 * about pattern matching here.
2555 */
2560 else
2562 }
2574 else
2579 /* All other types are printed as string literals. */
2583 fout);
2586 }
2587 }
2589 /* Terminate the row ... */
2592 /* ... and the statement, if the target no. of rows is reached */
2594 {
2597 else
2599 /* Reset the row counter */
2601 }
2602 }
2605 {
2608 }
2610 }
2612 /* Terminate any statements that didn't make the row count. */
2614 {
2617 else
2619 }
2630 /* Revert back the setting */
2635 }
2637 /*
2638 * getRootTableInfo:
2639 * get the root TableInfo for the given partition table.
2640 */
2643 {
2651 {
2654 }
2657 }
2659 /*
2660 * forcePartitionRootLoad
2661 * Check if we must force load_via_partition_root for this partition.
2662 *
2663 * This is required if any level of ancestral partitioned table has an
2664 * unsafe partitioning scheme.
2665 */
2666 static bool
2668 {
2678 {
2683 }
2686 }
2688 /*
2689 * dumpTableData -
2690 * dump the contents of a single table
2691 *
2692 * Actually, this just makes an ArchiveEntry for the table contents.
2693 */
2694 static void
2696 {
2701 DataDumperPtr dumpFn;
2706 /* We had better have loaded per-column details about this table */
2709 /*
2710 * When load-via-partition-root is set or forced, get the root table name
2711 * for the partition table, so that we can reload data through the root
2712 * table. Then construct a comment to be inserted into the TOC entry's
2713 * defn field, so that such cases can be identified reliably.
2714 */
2718 {
2724 copyFrom);
2726 }
2727 else
2731 {
2732 /* Dump/restore using COPY */
2734 /* must use 2 steps here 'cause fmtId is nonreentrant */
2736 copyFrom);
2740 }
2741 else
2742 {
2743 /* Restore using INSERT */
2746 }
2748 /*
2749 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2750 * dependency on its table as "special" and pass it to ArchiveEntry now.
2751 * See comments for BuildArchiveDependencies.
2752 */
2754 {
2770 /*
2771 * Set the TocEntry's dataLength in case we are doing a parallel dump
2772 * and want to order dump jobs by table size. We choose to measure
2773 * dataLength in table pages (including TOAST pages) during dump, so
2774 * no scaling is needed.
2775 *
2776 * However, relpages is declared as "integer" in pg_class, and hence
2777 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2778 * Cast so that we get the right interpretation of table sizes
2779 * exceeding INT_MAX pages.
2780 */
2784 /*
2785 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2786 * and instead we'd better worry about integer overflow. Clamp to
2787 * INT_MAX if the correct result exceeds that.
2788 */
2793 }
2797 }
2799 /*
2800 * refreshMatViewData -
2801 * load or refresh the contents of a single materialized view
2802 *
2803 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2804 * statement.
2805 */
2806 static void
2808 {
2810 PQExpBuffer q;
2812 /* If the materialized view is not flagged as populated, skip this. */
2835 }
2837 /*
2838 * getTableData -
2839 * set up dumpable objects representing the contents of tables
2840 */
2841 static void
2843 {
2847 {
2851 }
2852 }
2854 /*
2855 * Make a dumpable object for the data of this specific table
2856 *
2857 * Note: we make a TableDataInfo if and only if we are going to dump the
2858 * table data; the "dump" field in such objects isn't very interesting.
2859 */
2860 static void
2862 {
2865 /*
2866 * Nothing to do if we already decided to dump the table. This will
2867 * happen for "config" tables.
2868 */
2872 /* Skip VIEWs (no data to dump) */
2875 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
2881 /* Skip partitioned tables (data in partitions) */
2885 /* Don't dump data in unlogged tables, if so requested */
2890 /* Check that the data is not explicitly excluded */
2895 /* OK, let's dump it */
2902 else
2905 /*
2906 * Note: use tableoid 0 so that this object won't be mistaken for
2907 * something that pg_depend entries apply to.
2908 */
2918 /* A TableDataInfo contains data, of course */
2923 /* Make sure that we'll collect per-column info for this table. */
2925 }
2927 /*
2928 * The refresh for a materialized view must be dependent on the refresh for
2929 * any materialized view that this one is dependent on.
2930 *
2931 * This must be called after all the objects are created, but before they are
2932 * sorted.
2933 */
2934 static void
2936 {
2937 PQExpBuffer query;
2940 i;
2942 i_objid,
2943 i_refobjid;
2945 /* No Mat Views before 9.3. */
2952 "( "
2953 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
2954 "FROM pg_depend d1 "
2955 "JOIN pg_class c1 ON c1.oid = d1.objid "
2957 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
2958 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
2959 "AND d2.objid = r1.oid "
2960 "AND d2.refobjid <> d1.objid "
2961 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
2964 "WHERE d1.classid = 'pg_class'::regclass "
2965 "UNION "
2966 "SELECT w.objid, d3.refobjid, c3.relkind "
2967 "FROM w "
2968 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
2969 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
2970 "AND d3.objid = r3.oid "
2971 "AND d3.refobjid <> w.refobjid "
2972 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
2975 ") "
2976 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
2977 "FROM w "
2989 {
2990 CatalogId objId;
2991 CatalogId refobjId;
3030 }
3035 }
3037 /*
3038 * getTableDataFKConstraints -
3039 * add dump-order dependencies reflecting foreign key constraints
3040 *
3041 * This code is executed only in a data-only dump --- in schema+data dumps
3042 * we handle foreign key issues by not creating the FK constraints until
3043 * after the data is loaded. In a data-only dump, however, we want to
3044 * order the table data objects in such a way that a table's referenced
3045 * tables are restored first. (In the presence of circular references or
3046 * self-references this may be impossible; we'll detect and complain about
3047 * that during the dependency sorting step.)
3048 */
3049 static void
3051 {
3056 /* Search through all the dumpable objects for FK constraints */
3059 {
3061 {
3065 /* Not interesting unless both tables are to be dumped */
3074 /*
3075 * Okay, make referencing table's TABLE_DATA object depend on the
3076 * referenced table's TABLE_DATA object.
3077 */
3080 }
3081 }
3083 }
3086 /*
3087 * dumpDatabase:
3088 * dump the database definition
3089 */
3090 static void
3092 {
3101 i_oid,
3102 i_datname,
3103 i_datdba,
3104 i_encoding,
3105 i_datlocprovider,
3106 i_collate,
3107 i_ctype,
3108 i_datlocale,
3109 i_daticurules,
3110 i_frozenxid,
3111 i_minmxid,
3112 i_datacl,
3113 i_acldefault,
3114 i_datistemplate,
3115 i_datconnlimit,
3116 i_datcollversion,
3117 i_tablespace;
3118 CatalogId dbCatId;
3119 DumpId dbDumpId;
3120 DumpableAcl dbdacl;
3132 uint32 frozenxid,
3133 minmxid;
3138 /*
3139 * Fetch the database-level properties for this database.
3140 */
3142 "datdba, "
3143 "pg_encoding_to_char(encoding) AS encoding, "
3144 "datcollate, datctype, datfrozenxid, "
3145 "datacl, acldefault('d', datdba) AS acldefault, "
3149 else
3155 else
3156 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
3159 else
3162 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3163 "shobj_description(oid, 'pg_database') AS description "
3164 "FROM pg_database "
3198 else
3202 else
3214 /*
3215 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3216 * to preserve that), as well as the encoding, locale, and tablespace
3217 * since those can't be altered later. Other DB properties are left to
3218 * the DATABASE PROPERTIES entry, so that they can be applied after
3219 * reconnecting to the target DB.
3220 *
3221 * For binary upgrade, we use the FILE_COPY strategy because testing has
3222 * shown it to be faster. When the server is in binary upgrade mode, it
3223 * will also skip the checkpoints this strategy ordinarily performs.
3224 */
3226 {
3228 "CREATE DATABASE %s WITH TEMPLATE = template0 "
3231 }
3232 else
3233 {
3235 qdatname);
3236 }
3238 {
3241 }
3250 else
3252 datlocprovider);
3255 {
3258 }
3259 else
3260 {
3262 {
3265 }
3267 {
3270 }
3271 }
3273 {
3276 else
3280 }
3283 {
3286 }
3288 /*
3289 * For binary upgrade, carry over the collation version. For normal
3290 * dump/restore, omit the version, so that it is computed upon restore.
3291 */
3293 {
3295 {
3299 fout);
3300 }
3301 }
3303 /*
3304 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3305 * thing; the decision whether to specify a tablespace should be left till
3306 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3307 * label the DATABASE entry with the tablespace and let the normal
3308 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3309 * attention to default_tablespace, so that won't work.
3310 */
3318 qdatname);
3332 /* Compute correct tag for archive entry */
3335 /* Dump DB comment if any */
3336 {
3337 /*
3338 * 8.2 and up keep comments on shared objects in a shared table, so we
3339 * cannot use the dumpComment() code used for other database objects.
3340 * Be careful that the ArchiveEntry parameters match that function.
3341 */
3345 {
3348 /*
3349 * Generates warning when loaded into a differently-named
3350 * database.
3351 */
3364 }
3365 }
3367 /* Dump DB security label, if enabled */
3369 {
3371 PQExpBuffer seclabelQry;
3390 }
3392 /*
3393 * Dump ACL if any. Note that we do not support initial privileges
3394 * (pg_init_privs) on databases.
3395 */
3403 /*
3404 * Now construct a DATABASE PROPERTIES archive entry to restore any
3405 * non-default database-level properties. (The reason this must be
3406 * separate is that we cannot put any additional commands into the TOC
3407 * entry that has CREATE DATABASE. pg_restore would execute such a group
3408 * in an implicit transaction block, and the backend won't allow CREATE
3409 * DATABASE in that context.)
3410 */
3419 {
3421 qdatname);
3423 /*
3424 * The backend won't accept DROP DATABASE on a template database. We
3425 * can deal with that by removing the template marking before the DROP
3426 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3427 * since no such command is currently supported, fake it with a direct
3428 * UPDATE on pg_database.
3429 */
3434 }
3436 /*
3437 * We do not restore pg_database.dathasloginevt because it is set
3438 * automatically on login event trigger creation.
3439 */
3441 /* Add database-specific SET options */
3444 /*
3445 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3446 * entry, too, for lack of a better place.
3447 */
3449 {
3457 }
3469 /*
3470 * pg_largeobject comes from the old system intact, so set its
3471 * relfrozenxids, relminmxids and relfilenode.
3472 */
3474 {
3480 ii_relfilenode,
3481 ii_oid,
3482 ii_relminmxid;
3484 /*
3485 * pg_largeobject
3486 */
3492 else
3505 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3506 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3508 {
3509 Oid oid;
3510 RelFileNumber relfilenumber;
3525 relfilenumber);
3529 relfilenumber);
3530 }
3547 }
3556 }
3558 /*
3559 * Collect any database-specific or role-and-database-specific SET options
3560 * for this database, and append them to outbuf.
3561 */
3562 static void
3565 {
3570 /* First collect database-specific options */
3573 dboid);
3580 outbuf);
3584 /* Now look for role-and-database-specific options */
3586 "FROM pg_db_role_setting s, pg_roles r "
3588 dboid);
3596 outbuf);
3601 }
3603 /*
3604 * dumpEncoding: put the correct encoding into the archive
3605 */
3606 static void
3608 {
3625 }
3628 /*
3629 * dumpStdStrings: put the correct escape string behavior into the archive
3630 */
3631 static void
3633 {
3638 stdstrings);
3641 stdstrings);
3650 }
3652 /*
3653 * dumpSearchPath: record the active search_path in the archive
3654 */
3655 static void
3657 {
3665 /*
3666 * We use the result of current_schemas(), not the search_path GUC,
3667 * because that might contain wildcards such as "$user", which won't
3668 * necessarily have the same value during restore. Also, this way avoids
3669 * listing schemas that may appear in search_path but not actually exist,
3670 * which seems like a prudent exclusion.
3671 */
3678 /*
3679 * We use set_config(), not a simple "SET search_path" command, because
3680 * the latter has less-clean behavior if the search path is empty. While
3681 * that's likely to get fixed at some point, it seems like a good idea to
3682 * be as backwards-compatible as possible in what we put into archives.
3683 */
3685 {
3689 }
3703 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3710 }
3713 /*
3714 * getLOs:
3715 * Collect schema-level data about large objects
3716 */
3717 static void
3719 {
3733 /*
3734 * Fetch LO OIDs and owner/ACL data. Order the data so that all the blobs
3735 * with the same owner/ACL appear together.
3736 */
3738 "SELECT oid, lomowner, lomacl, "
3739 "acldefault('L', lomowner) AS acldefault "
3740 "FROM pg_largeobject_metadata "
3752 /*
3753 * Group the blobs into suitably-sized groups that have the same owner and
3754 * ACL setting, and build a metadata and a data DumpableObject for each
3755 * group. (If we supported initprivs for blobs, we'd have to insist that
3756 * groups also share initprivs settings, since the DumpableObject only has
3757 * room for one.) i is the index of the first tuple in the current group,
3758 * and n is the number of tuples we include in the group.
3759 */
3761 {
3769 /* Scan to find first tuple not to be included in group */
3772 {
3776 n++;
3777 }
3779 /* Build the metadata DumpableObject */
3790 else
3800 /* Collect OIDs of the remaining blobs in this group */
3802 {
3803 CatalogId extraID;
3807 /* Make sure we can look up loinfo by any of the blobs' OIDs */
3811 }
3813 /* LOs have data */
3816 /* Mark whether LO group has a non-empty ACL */
3820 /*
3821 * In binary-upgrade mode for LOs, we do *not* dump out the LO data,
3822 * as it will be copied by pg_upgrade, which simply copies the
3823 * pg_largeobject table. We *do* however dump out anything but the
3824 * data, as pg_upgrade copies just pg_largeobject, but not
3825 * pg_largeobject_metadata, after the dump is restored.
3826 */
3830 /*
3831 * Create a "BLOBS" data item for the group, too. This is just a
3832 * placeholder for sorting; it carries no data now.
3833 */
3840 /* Set up explicit dependency from data to metadata */
3844 }
3848 }
3850 /*
3851 * dumpLO
3852 *
3853 * dump the definition (metadata) of the given large object group
3854 */
3855 static void
3857 {
3860 /*
3861 * The "definition" is just a newline-separated list of OIDs. We need to
3862 * put something into the dropStmt too, but it can just be a comment.
3863 */
3876 /*
3877 * Dump per-blob comments and seclabels if any. We assume these are rare
3878 * enough that it's okay to generate retail TOC entries for them.
3879 */
3881 DUMP_COMPONENT_SECLABEL))
3882 {
3884 {
3885 CatalogId catId;
3888 /* Build identifying info for this blob */
3902 }
3903 }
3905 /*
3906 * Dump the ACLs if any (remember that all blobs in the group will have
3907 * the same ACL). If there's just one blob, dump a simple ACL entry; if
3908 * there's more, make a "LARGE OBJECTS" entry that really contains only
3909 * the ACL for the first blob. _printTocEntry() will be cued by the tag
3910 * string to emit a mutated version for each blob.
3911 */
3913 {
3916 /* Build identifying info for the first blob */
3920 {
3929 }
3930 else
3931 {
3935 }
3936 }
3939 }
3941 /*
3942 * dumpLOs:
3943 * dump the data contents of the large objects in the given group
3944 */
3945 static int
3947 {
3955 {
3960 /* Open the LO */
3968 /* Now read it in chunks, sending data to archive */
3969 do
3970 {
3982 }
3985 }
3987 /*
3988 * getPolicies
3989 * get information about all RLS policies on dumpable tables.
3990 */
3991 void
3993 {
3994 PQExpBuffer query;
3995 PQExpBuffer tbloids;
4008 j,
4009 ntups;
4011 /* No policies before 9.5 */
4018 /*
4019 * Identify tables of interest, and check which ones have RLS enabled.
4020 */
4023 {
4026 /* Ignore row security on tables not to be dumped */
4030 /* It can't have RLS or policies if it's not a table */
4035 /* Add it to the list of table OIDs to be probed below */
4040 /* Is RLS enabled? (That's separate from whether it has policies) */
4042 {
4045 /*
4046 * We represent RLS being enabled on a table by creating a
4047 * PolicyInfo object with null polname.
4048 *
4049 * Note: use tableoid 0 so that this object won't be mistaken for
4050 * something that pg_depend entries apply to.
4051 */
4066 }
4067 }
4070 /*
4071 * Now, read all RLS policies belonging to the tables of interest, and
4072 * create PolicyInfo objects for them. (Note that we must filter the
4073 * results server-side not locally, because we dare not apply pg_get_expr
4074 * to tables we don't have lock on.)
4075 */
4082 else
4085 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
4086 " pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(rolname) from pg_catalog.pg_roles WHERE oid = ANY(pol.polroles)), ', ') END AS polroles, "
4087 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
4088 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
4097 {
4111 {
4132 else
4137 else
4142 else
4145 }
4146 }
4152 }
4154 /*
4155 * dumpPolicy
4156 * dump the definition of the given policy
4157 */
4158 static void
4160 {
4163 PQExpBuffer query;
4164 PQExpBuffer delqry;
4165 PQExpBuffer polprefix;
4170 /* Do nothing if not dumping schema */
4174 /*
4175 * If polname is NULL, then this record is just indicating that ROW LEVEL
4176 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
4177 * ROW LEVEL SECURITY.
4178 */
4180 {
4186 /*
4187 * We must emit the ROW SECURITY object's dependency on its table
4188 * explicitly, because it will not match anything in pg_depend (unlike
4189 * the case for other PolicyInfo objects).
4190 */
4204 }
4216 else
4270 }
4272 /*
4273 * getPublications
4274 * get information about publications
4275 */
4276 void
4278 {
4280 PQExpBuffer query;
4295 ntups;
4302 /* Get the publications. */
4304 "p.pubowner, p.puballtables, p.pubinsert, "
4309 else
4314 else
4319 else
4346 {
4369 /* Decide whether we want to dump it */
4371 }
4373 cleanup:
4377 }
4379 /*
4380 * dumpPublication
4381 * dump the definition of the given publication
4382 */
4383 static void
4385 {
4387 PQExpBuffer delq;
4388 PQExpBuffer query;
4392 /* Do nothing if not dumping schema */
4402 qpubname);
4405 qpubname);
4412 {
4415 }
4418 {
4424 }
4427 {
4433 }
4436 {
4442 }
4476 }
4478 /*
4479 * getPublicationNamespaces
4480 * get information about publication membership for dumpable schemas.
4481 */
4482 void
4484 {
4485 PQExpBuffer query;
4494 j,
4495 ntups;
4502 /* Collect all publication membership info. */
4504 "SELECT tableoid, oid, pnpubid, pnnspid "
4515 /* this allocation may be more than we need */
4520 {
4526 /*
4527 * Ignore any entries for which we aren't interested in either the
4528 * publication or the rel.
4529 */
4537 /*
4538 * We always dump publication namespaces unless the corresponding
4539 * namespace is excluded from the dump.
4540 */
4544 /* OK, make a DumpableObject for this relationship */
4555 /* Decide whether we want to dump it */
4558 j++;
4559 }
4563 }
4565 /*
4566 * getPublicationTables
4567 * get information about publication membership for dumpable tables.
4568 */
4569 void
4571 {
4572 PQExpBuffer query;
4583 j,
4584 ntups;
4591 /* Collect all publication membership info. */
4594 "SELECT tableoid, oid, prpubid, prrelid, "
4595 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4600 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4603 " ELSE NULL END) prattrs "
4605 else
4607 "SELECT tableoid, oid, prpubid, prrelid, "
4608 "NULL AS prrelqual, NULL AS prattrs "
4621 /* this allocation may be more than we need */
4626 {
4632 /*
4633 * Ignore any entries for which we aren't interested in either the
4634 * publication or the rel.
4635 */
4643 /*
4644 * Ignore publication membership of tables whose definitions are not
4645 * to be dumped.
4646 */
4650 /* OK, make a DumpableObject for this relationship */
4662 else
4666 {
4669 PQExpBuffer attribs;
4676 {
4681 }
4683 }
4684 else
4687 /* Decide whether we want to dump it */
4690 j++;
4691 }
4695 }
4697 /*
4698 * dumpPublicationNamespace
4699 * dump the definition of the given publication schema mapping.
4700 */
4701 static void
4703 {
4707 PQExpBuffer query;
4710 /* Do nothing if not dumping schema */
4721 /*
4722 * There is no point in creating drop query as the drop is done by schema
4723 * drop.
4724 */
4734 /* These objects can't currently have comments or seclabels */
4738 }
4740 /*
4741 * dumpPublicationTable
4742 * dump the definition of the given publication table mapping
4743 */
4744 static void
4746 {
4750 PQExpBuffer query;
4753 /* Do nothing if not dumping schema */
4770 {
4771 /*
4772 * It's necessary to add parentheses around the expression because
4773 * pg_get_expr won't supply the parentheses for things like WHERE
4774 * TRUE.
4775 */
4777 }
4780 /*
4781 * There is no point in creating a drop query as the drop is done by table
4782 * drop. (If you think to change this, see also _printTocEntry().)
4783 * Although this object doesn't really have ownership as such, set the
4784 * owner field anyway to ensure that the command is run by the correct
4785 * role at restore time.
4786 */
4796 /* These objects can't currently have comments or seclabels */
4800 }
4802 /*
4803 * Is the currently connected user a superuser?
4804 */
4805 static bool
4807 {
4817 }
4819 /*
4820 * Set the given value to restrict_nonsystem_relation_kind value. Since
4821 * restrict_nonsystem_relation_kind is introduced in minor version releases,
4822 * the setting query is effective only where available.
4823 */
4824 static void
4826 {
4831 "SELECT set_config(name, '%s', false) "
4832 "FROM pg_settings "
4834 value);
4839 }
4841 /*
4842 * getSubscriptions
4843 * get information about subscriptions
4844 */
4845 void
4847 {
4849 PQExpBuffer query;
4871 ntups;
4877 {
4881 "SELECT count(*) FROM pg_subscription "
4882 "WHERE subdbid = (SELECT oid FROM pg_database"
4884 PGRES_TUPLES_OK);
4890 }
4894 /* Get the subscriptions in current database. */
4903 else
4908 else
4915 else
4919 LOGICALREP_TWOPHASE_STATE_DISABLED);
4926 else
4931 LOGICALREP_ORIGIN_ANY);
4936 else
4943 else
4963 /*
4964 * Get subscription fields. We don't include subskiplsn in the dump as
4965 * after restoring the dump this value may no longer be relevant.
4966 */
4989 {
5016 else
5026 else
5030 /* Decide whether we want to dump it */
5032 }
5036 }
5038 /*
5039 * getSubscriptionTables
5040 * Get information about subscription membership for dumpable tables. This
5041 * will be used only in binary-upgrade mode for PG17 or later versions.
5042 */
5043 void
5045 {
5062 "SELECT srsubid, srrelid, srsubstate, srsublsn "
5063 "FROM pg_catalog.pg_subscription_rel "
5065 PGRES_TUPLES_OK);
5070 /* Get pg_subscription_rel attributes */
5078 {
5083 /*
5084 * If we switched to a new subscription, check if the subscription
5085 * exists.
5086 */
5088 {
5094 }
5099 relid);
5101 /* OK, make a DumpableObject for this relationship */
5111 else
5116 /* Decide whether we want to dump it */
5118 }
5120 cleanup:
5122 }
5124 /*
5125 * dumpSubscriptionTable
5126 * Dump the definition of the given subscription table mapping. This will be
5127 * used only in binary-upgrade mode for PG17 or later versions.
5128 */
5129 static void
5131 {
5134 PQExpBuffer query;
5137 /* Do nothing if not dumping schema */
5148 {
5149 /*
5150 * binary_upgrade_add_sub_rel_state will add the subscription relation
5151 * to pg_subscription_rel table. This will be used only in
5152 * binary-upgrade mode.
5153 */
5166 else
5170 }
5172 /*
5173 * There is no point in creating a drop query as the drop is done by table
5174 * drop. (If you think to change this, see also _printTocEntry().)
5175 * Although this object doesn't really have ownership as such, set the
5176 * owner field anyway to ensure that the command is run by the correct
5177 * role at restore time.
5178 */
5188 /* These objects can't currently have comments or seclabels */
5192 }
5194 /*
5195 * dumpSubscription
5196 * dump the definition of the given subscription
5197 */
5198 static void
5200 {
5202 PQExpBuffer delq;
5203 PQExpBuffer query;
5204 PQExpBuffer publications;
5210 /* Do nothing if not dumping schema */
5220 qsubname);
5223 qsubname);
5226 /* Build list of quoted publications and append them to query. */
5232 {
5237 }
5239 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
5242 else
5252 else
5278 /*
5279 * In binary-upgrade mode, we allow the replication to continue after the
5280 * upgrade.
5281 */
5283 {
5285 {
5286 /*
5287 * Preserve the remote_lsn for the subscriber's replication
5288 * origin. This value is required to start the replication from
5289 * the position before the upgrade. This value will be stale if
5290 * the publisher gets upgraded before the subscriber node.
5291 * However, this shouldn't be a problem as the upgrade of the
5292 * publisher ensures that all the transactions were replicated
5293 * before upgrading it.
5294 */
5296 "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
5301 }
5304 {
5305 /*
5306 * Enable the subscription to allow the replication to continue
5307 * after the upgrade.
5308 */
5312 }
5313 }
5340 }
5342 /*
5343 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
5344 * the object needs.
5345 */
5346 static void
5348 PQExpBuffer create,
5353 {
5355 {
5358 PQExpBuffer query;
5363 /* dodge fmtId() non-reentrancy */
5368 "SELECT e.extname "
5369 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5370 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5371 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5373 catalog,
5379 {
5383 }
5388 }
5389 }
5391 static Oid
5393 {
5394 /*
5395 * If the old version didn't assign an array type, but the new version
5396 * does, we must select an unused type OID to assign. This currently only
5397 * happens for domains, when upgrading pre-v11 to v11 and up.
5398 *
5399 * Note: local state here is kind of ugly, but we must have some, since we
5400 * mustn't choose the same unused OID more than once.
5401 */
5406 do
5407 {
5410 "SELECT EXISTS(SELECT 1 "
5411 "FROM pg_catalog.pg_type "
5413 next_possible_free_oid);
5420 }
5422 static void
5424 PQExpBuffer upgrade_buffer,
5425 Oid pg_type_oid,
5428 {
5431 Oid pg_type_array_oid;
5432 Oid pg_type_multirange_oid;
5433 Oid pg_type_multirange_array_oid;
5439 pg_type_oid);
5444 else
5451 {
5456 pg_type_array_oid);
5457 }
5459 /*
5460 * Pre-set the multirange type oid and its own array type oid.
5461 */
5463 {
5465 {
5467 "SELECT t.oid, t.typarray "
5468 "FROM pg_catalog.pg_type t "
5469 "JOIN pg_catalog.pg_range r "
5470 "ON t.oid = r.rngmultitypid "
5472 pg_type_oid);
5480 }
5481 else
5482 {
5485 }
5491 pg_type_multirange_oid);
5495 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5496 pg_type_multirange_array_oid);
5497 }
5500 }
5502 static void
5504 PQExpBuffer upgrade_buffer,
5506 {
5512 }
5514 /*
5515 * bsearch() comparator for BinaryUpgradeClassOidItem
5516 */
5517 static int
5519 {
5524 }
5526 /*
5527 * collectBinaryUpgradeClassOids
5528 *
5529 * Construct a table of pg_class information required for
5530 * binary_upgrade_set_pg_class_oids(). The table is sorted by OID for speed in
5531 * lookup.
5532 */
5533 static void
5535 {
5540 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5541 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5542 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5543 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5544 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5554 {
5562 }
5565 }
5567 static void
5570 {
5576 /*
5577 * Preserve the OID and relfilenumber of the table, table's index, table's
5578 * toast table and toast table's index if any.
5579 *
5580 * One complexity is that the current table definition might not require
5581 * the creation of a TOAST table, but the old database might have a TOAST
5582 * table that was created earlier, before some wide columns were dropped.
5583 * By setting the TOAST oid we force creation of the TOAST heap and index
5584 * by the new backend, so we can copy the files during binary upgrade
5585 * without worrying about this case.
5586 */
5590 BinaryUpgradeClassOidItemCmp);
5597 {
5600 pg_class_oid);
5602 /*
5603 * Not every relation has storage. Also, in a pre-v12 database,
5604 * partitioned tables have a relfilenumber, which should not be
5605 * preserved when upgrading.
5606 */
5613 /*
5614 * In a pre-v12 database, partitioned tables might be marked as having
5615 * toast tables, but we should ignore them if so.
5616 */
5619 {
5627 /* every toast table has an index */
5634 }
5635 }
5636 else
5637 {
5638 /* Preserve the OID and relfilenumber of the index */
5641 pg_class_oid);
5645 }
5648 }
5650 /*
5651 * If the DumpableObject is a member of an extension, add a suitable
5652 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
5653 *
5654 * For somewhat historical reasons, objname should already be quoted,
5655 * but not objnamespace (if any).
5656 */
5657 static void
5663 {
5670 /*
5671 * Find the parent extension. We could avoid this search if we wanted to
5672 * add a link field to DumpableObject, but the space costs of that would
5673 * be considerable. We assume that member objects could only have a
5674 * direct dependency on their own extension, not any others.
5675 */
5677 {
5682 }
5691 objtype);
5695 }
5697 /*
5698 * getNamespaces:
5699 * get information about all namespaces in the system catalogs
5700 */
5701 void
5703 {
5707 PQExpBuffer query;
5718 /*
5719 * we fetch all namespaces including system ones, so that every object we
5720 * read in can be linked to a containing namespace.
5721 */
5723 "n.nspowner, "
5724 "n.nspacl, "
5725 "acldefault('n', n.nspowner) AS acldefault "
5742 {
5758 /* Decide whether to dump this namespace */
5761 /* Mark whether namespace has an ACL */
5765 /*
5766 * We ignore any pg_init_privs.initprivs entry for the public schema
5767 * and assume a predetermined default, for several reasons. First,
5768 * dropping and recreating the schema removes its pg_init_privs entry,
5769 * but an empty destination database starts with this ACL nonetheless.
5770 * Second, we support dump/reload of public schema ownership changes.
5771 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
5772 * initprivs continues to reflect the initial owner. Hence,
5773 * synthesize the value that nspacl will have after the restore's
5774 * ALTER SCHEMA OWNER. Third, this makes the destination database
5775 * match the source's ACL, even if the latter was an initdb-default
5776 * ACL, which changed in v15. An upgrade pulls in changes to most
5777 * system object ACLs that the DBA had not customized. We've made the
5778 * public schema depart from that, because changing its ACL so easily
5779 * breaks applications.
5780 */
5782 {
5786 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
5804 }
5805 }
5809 }
5811 /*
5812 * findNamespace:
5813 * given a namespace OID, look up the info read by getNamespaces
5814 */
5817 {
5824 }
5826 /*
5827 * getExtensions:
5828 * read all extensions in the system catalogs and return them in the
5829 * ExtensionInfo* structure
5830 *
5831 * numExtensions is set to the number of extensions read in
5832 */
5833 ExtensionInfo *
5835 {
5840 PQExpBuffer query;
5854 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
5855 "FROM pg_extension x "
5876 {
5888 /* Decide whether we want to dump it */
5890 }
5892 cleanup:
5899 }
5901 /*
5902 * getTypes:
5903 * get information about all types in the system catalogs
5904 *
5905 * NB: this must run after getFuncs() because we assume we can do
5906 * findFuncByOid().
5907 */
5908 void
5910 {
5932 /*
5933 * we include even the built-in types because those may be used as array
5934 * elements by user-defined types
5935 *
5936 * we filter out the built-in types when we dump out the types
5937 *
5938 * same approach for undefined (shell) types and array types
5939 *
5940 * Note: as of 8.3 we can reliably detect whether a type is an
5941 * auto-generated array type by checking the element type's typarray.
5942 * (Before that the test is capable of generating false positives.) We
5943 * still check for name beginning with '_', though, so as to avoid the
5944 * cost of the subselect probe for all standard types. This would have to
5945 * be revisited if the backend ever allows renaming of array types.
5946 */
5948 "typnamespace, typacl, "
5949 "acldefault('T', typowner) AS acldefault, "
5950 "typowner, "
5951 "typelem, typrelid, typarray, "
5953 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
5954 "typtype, typisdefined, "
5955 "typname[0] = '_' AND typelem != 0 AND "
5956 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
5981 {
6003 else
6008 else
6015 else
6018 /* Decide whether we want to dump it */
6021 /* Mark whether type has an ACL */
6025 /*
6026 * If it's a domain, fetch info about its constraints, if any
6027 */
6034 /*
6035 * If it's a base type, make a DumpableObject representing a shell
6036 * definition of the type. We will need to dump that ahead of the I/O
6037 * functions for the type. Similarly, range types need a shell
6038 * definition in case they have a canonicalize function.
6039 *
6040 * Note: the shell type doesn't have a catId. You might think it
6041 * should copy the base type's catId, but then it might capture the
6042 * pg_depend entries for the type, which we don't want.
6043 */
6047 {
6057 /*
6058 * Initially mark the shell type as not to be dumped. We'll only
6059 * dump it if the I/O or canonicalize functions need to be dumped;
6060 * this is taken care of while sorting dependencies.
6061 */
6063 }
6064 }
6069 }
6071 /*
6072 * getOperators:
6073 * get information about all operators in the system catalogs
6074 */
6075 void
6077 {
6091 /*
6092 * find all operators, including builtin operators; we filter out
6093 * system-defined operators at dump-out time.
6094 */
6097 "oprnamespace, "
6098 "oprowner, "
6099 "oprkind, "
6100 "oprcode::oid AS oprcode "
6118 {
6130 /* Decide whether we want to dump it */
6132 }
6137 }
6139 /*
6140 * getCollations:
6141 * get information about all collations in the system catalogs
6142 */
6143 void
6145 {
6149 PQExpBuffer query;
6159 /*
6160 * find all collations, including builtin collations; we filter out
6161 * system-defined collations at dump-out time.
6162 */
6165 "collnamespace, "
6166 "collowner "
6182 {
6192 /* Decide whether we want to dump it */
6194 }
6199 }
6201 /*
6202 * getConversions:
6203 * get information about all conversions in the system catalogs
6204 */
6205 void
6207 {
6211 PQExpBuffer query;
6221 /*
6222 * find all conversions, including builtin conversions; we filter out
6223 * system-defined conversions at dump-out time.
6224 */
6227 "connamespace, "
6228 "conowner "
6244 {
6254 /* Decide whether we want to dump it */
6256 }
6261 }
6263 /*
6264 * getAccessMethods:
6265 * get information about all user-defined access methods
6266 */
6267 void
6269 {
6273 PQExpBuffer query;
6281 /* Before 9.6, there are no user-defined access methods */
6287 /* Select all access methods from pg_am table */
6289 "amhandler::pg_catalog.regproc AS amhandler "
6305 {
6315 /* Decide whether we want to dump it */
6317 }
6322 }
6325 /*
6326 * getOpclasses:
6327 * get information about all opclasses in the system catalogs
6328 */
6329 void
6331 {
6343 /*
6344 * find all opclasses, including builtin opclasses; we filter out
6345 * system-defined opclasses at dump-out time.
6346 */
6349 "opcnamespace, "
6350 "opcowner "
6366 {
6376 /* Decide whether we want to dump it */
6378 }
6383 }
6385 /*
6386 * getOpfamilies:
6387 * get information about all opfamilies in the system catalogs
6388 */
6389 void
6391 {
6395 PQExpBuffer query;
6405 /*
6406 * find all opfamilies, including builtin opfamilies; we filter out
6407 * system-defined opfamilies at dump-out time.
6408 */
6411 "opfnamespace, "
6412 "opfowner "
6428 {
6438 /* Decide whether we want to dump it */
6440 }
6445 }
6447 /*
6448 * getAggregates:
6449 * get information about all user-defined aggregates in the system catalogs
6450 */
6451 void
6453 {
6470 /*
6471 * Find all interesting aggregates. See comment in getFuncs() for the
6472 * rationale behind the filtering logic.
6473 */
6475 {
6482 "p.proname AS aggname, "
6483 "p.pronamespace AS aggnamespace, "
6484 "p.pronargs, p.proargtypes, "
6485 "p.proowner, "
6486 "p.proacl AS aggacl, "
6487 "acldefault('f', p.proowner) AS acldefault "
6488 "FROM pg_proc p "
6489 "LEFT JOIN pg_init_privs pip ON "
6490 "(p.oid = pip.objoid "
6491 "AND pip.classoid = 'pg_proc'::regclass "
6492 "AND pip.objsubid = 0) "
6493 "WHERE %s AND ("
6494 "p.pronamespace != "
6495 "(SELECT oid FROM pg_namespace "
6496 "WHERE nspname = 'pg_catalog') OR "
6498 agg_check);
6501 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6502 "classid = 'pg_proc'::regclass AND "
6503 "objid = p.oid AND "
6504 "refclassid = 'pg_extension'::regclass AND "
6507 }
6508 else
6509 {
6511 "pronamespace AS aggnamespace, "
6512 "pronargs, proargtypes, "
6513 "proowner, "
6514 "proacl AS aggacl, "
6515 "acldefault('f', proowner) AS acldefault "
6516 "FROM pg_proc p "
6517 "WHERE proisagg AND ("
6518 "pronamespace != "
6519 "(SELECT oid FROM pg_namespace "
6523 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6524 "classid = 'pg_proc'::regclass AND "
6525 "objid = p.oid AND "
6526 "refclassid = 'pg_extension'::regclass AND "
6529 }
6548 {
6566 else
6567 {
6572 }
6575 /* Decide whether we want to dump it */
6578 /* Mark whether aggregate has an ACL */
6581 }
6586 }
6588 /*
6589 * getFuncs:
6590 * get information about all user-defined functions in the system catalogs
6591 */
6592 void
6594 {
6613 /*
6614 * Find all interesting functions. This is a bit complicated:
6615 *
6616 * 1. Always exclude aggregates; those are handled elsewhere.
6617 *
6618 * 2. Always exclude functions that are internally dependent on something
6619 * else, since presumably those will be created as a result of creating
6620 * the something else. This currently acts only to suppress constructor
6621 * functions for range types. Note this is OK only because the
6622 * constructors don't have any dependencies the range type doesn't have;
6623 * otherwise we might not get creation ordering correct.
6624 *
6625 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
6626 * they're members of extensions and we are in binary-upgrade mode then
6627 * include them, since we want to dump extension members individually in
6628 * that mode. Also, if they are used by casts or transforms then we need
6629 * to gather the information about them, though they won't be dumped if
6630 * they are built-in. Also, in 9.6 and up, include functions in
6631 * pg_catalog if they have an ACL different from what's shown in
6632 * pg_init_privs (so we have to join to pg_init_privs; annoying).
6633 */
6635 {
6642 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
6643 "p.pronargs, p.proargtypes, p.prorettype, "
6644 "p.proacl, "
6645 "acldefault('f', p.proowner) AS acldefault, "
6646 "p.pronamespace, "
6647 "p.proowner "
6648 "FROM pg_proc p "
6649 "LEFT JOIN pg_init_privs pip ON "
6650 "(p.oid = pip.objoid "
6651 "AND pip.classoid = 'pg_proc'::regclass "
6652 "AND pip.objsubid = 0) "
6653 "WHERE %s"
6655 "WHERE classid = 'pg_proc'::regclass AND "
6656 "objid = p.oid AND deptype = 'i')"
6659 "(SELECT oid FROM pg_namespace "
6660 "WHERE nspname = 'pg_catalog')"
6668 not_agg_check,
6669 g_last_builtin_oid,
6670 g_last_builtin_oid);
6674 "classid = 'pg_proc'::regclass AND "
6675 "objid = p.oid AND "
6676 "refclassid = 'pg_extension'::regclass AND "
6681 }
6682 else
6683 {
6685 "SELECT tableoid, oid, proname, prolang, "
6686 "pronargs, proargtypes, prorettype, proacl, "
6687 "acldefault('f', proowner) AS acldefault, "
6688 "pronamespace, "
6689 "proowner "
6690 "FROM pg_proc p "
6691 "WHERE NOT proisagg"
6693 "WHERE classid = 'pg_proc'::regclass AND "
6694 "objid = p.oid AND deptype = 'i')"
6697 "(SELECT oid FROM pg_namespace "
6698 "WHERE nspname = 'pg_catalog')"
6702 g_last_builtin_oid);
6710 g_last_builtin_oid);
6715 "classid = 'pg_proc'::regclass AND "
6716 "objid = p.oid AND "
6717 "refclassid = 'pg_extension'::regclass AND "
6720 }
6741 {
6759 else
6760 {
6764 }
6767 /* Decide whether we want to dump it */
6770 /* Mark whether function has an ACL */
6773 }
6778 }
6780 /*
6781 * getTables
6782 * read all the tables (no indexes) in the system catalogs,
6783 * and return them as an array of TableInfo structures
6784 *
6785 * *numTables is set to the number of tables read in
6786 */
6787 TableInfo *
6789 {
6834 /*
6835 * Find all the tables and table-like objects.
6836 *
6837 * We must fetch all tables in this phase because otherwise we cannot
6838 * correctly identify inherited columns, owned sequences, etc.
6839 *
6840 * We include system catalogs, so that we can work if a user table is
6841 * defined to inherit from a system catalog (pretty weird, but...)
6842 *
6843 * Note: in this phase we should collect only a minimal amount of
6844 * information about each table, basically just enough to decide if it is
6845 * interesting. In particular, since we do not yet have lock on any user
6846 * table, we MUST NOT invoke any server-side data collection functions
6847 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
6848 * wrong answers if any concurrent DDL is happening.
6849 */
6852 "SELECT c.tableoid, c.oid, c.relname, "
6853 "c.relnamespace, c.relkind, c.reltype, "
6854 "c.relowner, "
6855 "c.relchecks, "
6856 "c.relhasindex, c.relhasrules, c.relpages, "
6857 "c.relhastriggers, "
6858 "c.relpersistence, "
6859 "c.reloftype, "
6860 "c.relacl, "
6864 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
6865 "ELSE 0 END AS foreignserver, "
6866 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
6867 "tc.oid AS toid, "
6868 "tc.relpages AS toastpages, "
6869 "tc.reloptions AS toast_reloptions, "
6870 "d.refobjid AS owning_tab, "
6871 "d.refobjsubid AS owning_col, "
6877 else
6884 else
6891 else
6898 else
6900 "false AS relrowsecurity, "
6906 else
6912 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6913 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6914 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
6915 else
6922 else
6929 else
6936 else
6940 /*
6941 * Left join to pg_depend to pick up dependency info linking sequences to
6942 * their owning column, if any (note this dependency is AUTO except for
6943 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
6944 * collect the spcname.
6945 */
6948 "LEFT JOIN pg_depend d ON "
6950 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
6951 "d.objsubid = 0 AND "
6955 /*
6956 * In 9.6 and up, left join to pg_am to pick up the amname.
6957 */
6962 /*
6963 * We purposefully ignore toast OIDs for partitioned tables; the reason is
6964 * that versions 10 and 11 have them, but later versions do not, so
6965 * emitting them causes the upgrade to fail.
6966 */
6968 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
6972 /*
6973 * Restrict to interesting relkinds (in particular, not indexes). Not all
6974 * relkinds are possible in older servers, but it's not worth the trouble
6975 * to emit a version-dependent list.
6976 *
6977 * Composite-type table entries won't be dumped as such, but we have to
6978 * make a DumpableObject for them so that we can track dependencies of the
6979 * composite type (pg_depend entries for columns of the composite type
6980 * link to the pg_class entry not the pg_type entry).
6981 */
6983 "WHERE c.relkind IN ("
6999 /*
7000 * Extract data from result and lock dumpable tables. We do the locking
7001 * before anything else, to minimize the window wherein a table could
7002 * disappear under us.
7003 *
7004 * Note that we have to save info about all tables here, even when dumping
7005 * only one, because we don't yet know which tables might be inheritance
7006 * ancestors of the target table.
7007 */
7049 {
7050 /*
7051 * Arrange to fail instead of waiting forever for a table lock.
7052 *
7053 * NB: this coding assumes that the only queries issued within the
7054 * following loop are LOCK TABLEs; else the timeout may be undesirably
7055 * applied to other things too.
7056 */
7061 }
7066 {
7087 else
7090 {
7093 }
7094 else
7095 {
7098 }
7115 else
7122 else
7124 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
7127 /* other fields were zeroed above */
7129 /*
7130 * Decide whether we want to dump this table.
7131 */
7134 else
7137 /*
7138 * Now, consider the table "interesting" if we need to dump its
7139 * definition or its data. Later on, we'll skip a lot of data
7140 * collection for uninteresting tables.
7141 *
7142 * Note: the "interesting" flag will also be set by flagInhTables for
7143 * parents of interesting tables, so that we collect necessary
7144 * inheritance info even when the parents are not themselves being
7145 * dumped. This is the main reason why we need an "interesting" flag
7146 * that's separate from the components-to-dump bitmask.
7147 */
7155 /* Tables have data */
7158 /* Mark whether table has an ACL */
7163 /*
7164 * Read-lock target tables to make sure they aren't DROPPED or altered
7165 * in schema before we get around to dumping them.
7166 *
7167 * Note that we don't explicitly lock parents of the target tables; we
7168 * assume our lock on the child is enough to prevent schema
7169 * alterations to parent tables.
7170 *
7171 * NOTE: it'd be kinda nice to lock other relations too, not only
7172 * plain or partitioned tables, but the backend doesn't presently
7173 * allow that.
7174 *
7175 * We only need to lock the table for certain components; see
7176 * pg_dump.h
7177 */
7181 {
7182 /*
7183 * Tables are locked in batches. When dumping from a remote
7184 * server this can save a significant amount of time by reducing
7185 * the number of round trips.
7186 */
7190 else
7191 {
7195 /* Arbitrarily end a batch when query length reaches 100K. */
7197 {
7198 /* Lock another batch of tables. */
7202 }
7203 }
7204 }
7205 }
7208 {
7209 /* Lock the tables in the last batch. */
7212 }
7215 {
7217 }
7224 }
7226 /*
7227 * getOwnedSeqs
7228 * identify owned sequences and mark them as dumpable if owning table is
7229 *
7230 * We used to do this in getTables(), but it's better to do it after the
7231 * index used by findTableByOid() has been set up.
7232 */
7233 void
7235 {
7238 /*
7239 * Force sequences that are "owned" by table columns to be dumped whenever
7240 * their owning table is being dumped.
7241 */
7243 {
7255 /*
7256 * For an identity sequence, dump exactly the same components for the
7257 * sequence as for the owning table. This is important because we
7258 * treat the identity sequence as an integral part of the table. For
7259 * example, there is not any DDL command that allows creation of such
7260 * a sequence independently of the table.
7261 *
7262 * For other owned sequences such as serial sequences, we need to dump
7263 * the components that are being dumped for the table and any
7264 * components that the sequence is explicitly marked with.
7265 *
7266 * We can't simply use the set of components which are being dumped
7267 * for the table as the table might be in an extension (and only the
7268 * non-extension components, eg: ACLs if changed, security labels, and
7269 * policies, are being dumped) while the sequence is not (and
7270 * therefore the definition and other components should also be
7271 * dumped).
7272 *
7273 * If the sequence is part of the extension then it should be properly
7274 * marked by checkExtensionMembership() and this will be a no-op as
7275 * the table will be equivalently marked.
7276 */
7279 else
7282 /* Make sure that necessary data is available if we're dumping it */
7284 {
7287 }
7288 }
7289 }
7291 /*
7292 * getInherits
7293 * read all the inheritance information
7294 * from the system catalogs return them in the InhInfo* structure
7295 *
7296 * numInherits is set to the number of pairs read in
7297 */
7298 InhInfo *
7300 {
7310 /* find all the inheritance information */
7325 {
7328 }
7335 }
7337 /*
7338 * getPartitioningInfo
7339 * get information about partitioning
7340 *
7341 * For the most part, we only collect partitioning info about tables we
7342 * intend to dump. However, this function has to consider all partitioned
7343 * tables in the database, because we need to know about parents of partitions
7344 * we are going to dump even if the parents themselves won't be dumped.
7345 *
7346 * Specifically, what we need to know is whether each partitioned table
7347 * has an "unsafe" partitioning scheme that requires us to force
7348 * load-via-partition-root mode for its children. Currently the only case
7349 * for which we force that is hash partitioning on enum columns, since the
7350 * hash codes depend on enum value OIDs which won't be replicated across
7351 * dump-and-reload. There are other cases in which load-via-partition-root
7352 * might be necessary, but we expect users to cope with them.
7353 */
7354 void
7356 {
7357 PQExpBuffer query;
7361 /* hash partitioning didn't exist before v11 */
7364 /* needn't bother if not dumping data */
7370 /*
7371 * Unsafe partitioning schemes are exactly those for which hash enum_ops
7372 * appears among the partition opclasses. We needn't check partstrat.
7373 *
7374 * Note that this query may well retrieve info about tables we aren't
7375 * going to dump and hence have no lock on. That's okay since we need not
7376 * invoke any unsafe server-side functions.
7377 */
7380 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7382 "WHERE opcname = 'enum_ops' "
7383 "AND opcnamespace = 'pg_catalog'::regnamespace "
7391 {
7398 tabrelid);
7400 }
7405 }
7407 /*
7408 * getIndexes
7409 * get information about every index on a dumpable table
7410 *
7411 * Note: index data is not returned directly to the caller, but it
7412 * does get entered into the DumpableObject tables.
7413 */
7414 void
7416 {
7424 i_oid,
7425 i_indrelid,
7426 i_indexname,
7427 i_parentidx,
7428 i_indexdef,
7429 i_indnkeyatts,
7430 i_indnatts,
7431 i_indkey,
7432 i_indisclustered,
7433 i_indisreplident,
7434 i_indnullsnotdistinct,
7435 i_contype,
7436 i_conname,
7437 i_condeferrable,
7438 i_condeferred,
7439 i_conperiod,
7440 i_contableoid,
7441 i_conoid,
7442 i_condef,
7443 i_tablespace,
7444 i_indreloptions,
7445 i_indstatcols,
7446 i_indstatvals;
7448 /*
7449 * We want to perform just one query against pg_index. However, we
7450 * mustn't try to select every row of the catalog and then sort it out on
7451 * the client side, because some of the server-side functions we need
7452 * would be unsafe to apply to tables we don't have lock on. Hence, we
7453 * build an array of the OIDs of tables we care about (and now have lock
7454 * on!), and use a WHERE clause to constrain which rows are selected.
7455 */
7458 {
7464 /*
7465 * We can ignore indexes of uninteresting tables.
7466 */
7470 /* OK, we need info for this table */
7474 }
7478 "SELECT t.tableoid, t.oid, i.indrelid, "
7479 "t.relname AS indexname, "
7480 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7481 "i.indkey, i.indisclustered, "
7482 "c.contype, c.conname, "
7483 "c.condeferrable, c.condeferred, "
7484 "c.tableoid AS contableoid, "
7485 "c.oid AS conoid, "
7486 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7487 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7494 else
7500 "inh.inhparent AS parentidx, "
7501 "i.indnkeyatts AS indnkeyatts, "
7502 "i.indnatts AS indnatts, "
7503 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7504 " FROM pg_catalog.pg_attribute "
7505 " WHERE attrelid = i.indexrelid AND "
7506 " attstattarget >= 0) AS indstatcols, "
7507 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7508 " FROM pg_catalog.pg_attribute "
7509 " WHERE attrelid = i.indexrelid AND "
7511 else
7513 "0 AS parentidx, "
7514 "i.indnatts AS indnkeyatts, "
7515 "i.indnatts AS indnatts, "
7516 "'' AS indstatcols, "
7522 else
7529 else
7533 /*
7534 * The point of the messy-looking outer join is to find a constraint that
7535 * is related by an internal dependency link to the index. If we find one,
7536 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
7537 * index won't have more than one internal dependency.
7538 *
7539 * Note: the check on conrelid is redundant, but useful because that
7540 * column is indexed while conindid is not.
7541 */
7543 {
7546 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7547 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7548 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
7549 "LEFT JOIN pg_catalog.pg_constraint c "
7550 "ON (i.indrelid = c.conrelid AND "
7551 "i.indexrelid = c.conindid AND "
7552 "c.contype IN ('p','u','x')) "
7553 "LEFT JOIN pg_catalog.pg_inherits inh "
7554 "ON (inh.inhrelid = indexrelid) "
7555 "WHERE (i.indisvalid OR t2.relkind = 'p') "
7556 "AND i.indisready "
7559 }
7560 else
7561 {
7562 /*
7563 * the test on indisready is necessary in 9.2, and harmless in
7564 * earlier/later versions
7565 */
7568 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7569 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7570 "LEFT JOIN pg_catalog.pg_constraint c "
7571 "ON (i.indrelid = c.conrelid AND "
7572 "i.indexrelid = c.conindid AND "
7573 "c.contype IN ('p','u','x')) "
7574 "WHERE i.indisvalid AND i.indisready "
7577 }
7610 /*
7611 * Outer loop iterates once per table, not once per row. Incrementing of
7612 * j is handled by the inner loop.
7613 */
7616 {
7621 /* Count rows for this table */
7626 /*
7627 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
7628 * order.
7629 */
7631 {
7635 }
7638 /* cross-check that we only got requested tables */
7644 /* Save data for this table */
7649 {
7675 {
7676 NULL, NULL
7677 };
7681 {
7682 /*
7683 * If we found a constraint matching the index, create an
7684 * entry for it.
7685 */
7701 else
7712 }
7713 else
7714 {
7715 /* Plain secondary index */
7717 }
7718 }
7719 }
7725 }
7727 /*
7728 * getExtendedStatistics
7729 * get information about extended-statistics objects.
7730 *
7731 * Note: extended statistics data is not returned directly to the caller, but
7732 * it does get entered into the DumpableObject tables.
7733 */
7734 void
7736 {
7737 PQExpBuffer query;
7750 /* Extended statistics were new in v10 */
7758 "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
7760 else
7762 "stxnamespace, stxowner, stxrelid, stxstattarget "
7780 {
7793 else
7796 /* Decide whether we want to dump it */
7798 }
7802 }
7804 /*
7805 * getConstraints
7806 *
7807 * Get info about constraints on dumpable tables.
7808 *
7809 * Currently handles foreign keys only.
7810 * Unique and primary key constraints are handled with indexes,
7811 * while check constraints are processed in getTableAttrs().
7812 */
7813 void
7815 {
7824 i_conoid,
7825 i_conrelid,
7826 i_conname,
7827 i_confrelid,
7828 i_conindid,
7829 i_condef;
7831 /*
7832 * We want to perform just one query against pg_constraint. However, we
7833 * mustn't try to select every row of the catalog and then sort it out on
7834 * the client side, because some of the server-side functions we need
7835 * would be unsafe to apply to tables we don't have lock on. Hence, we
7836 * build an array of the OIDs of tables we care about (and now have lock
7837 * on!), and use a WHERE clause to constrain which rows are selected.
7838 */
7841 {
7844 /*
7845 * For partitioned tables, foreign keys have no triggers so they must
7846 * be included anyway in case some foreign keys are defined.
7847 */
7853 /* OK, we need info for this table */
7857 }
7861 "SELECT c.tableoid, c.oid, "
7865 else
7895 {
7899 /*
7900 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
7901 * order.
7902 */
7904 {
7906 {
7910 }
7913 }
7932 /*
7933 * Restoring an FK that points to a partitioned table requires that
7934 * all partition indexes have been attached beforehand. Ensure that
7935 * happens by making the constraint depend on each index partition
7936 * attach object.
7937 */
7940 {
7944 {
7946 {
7949 /* not our index? */
7956 }
7957 }
7958 }
7959 }
7965 }
7967 /*
7968 * addConstrChildIdxDeps
7969 *
7970 * Recursive subroutine for getConstraints
7971 *
7972 * Given an object representing a foreign key constraint and an index on the
7973 * partitioned table it references, mark the constraint object as dependent
7974 * on the DO_INDEX_ATTACH object of each index partition, recursively
7975 * drilling down to their partitions if any. This ensures that the FK is not
7976 * restored until the index is fully marked valid.
7977 */
7978 static void
7980 {
7986 {
7993 }
7994 }
7996 /*
7997 * getDomainConstraints
7998 *
7999 * Get info about constraints on a domain.
8000 */
8001 static void
8003 {
8009 i_oid,
8010 i_conname,
8011 i_consrc;
8015 {
8016 /* Set up query for constraint-specific details */
8019 "SELECT tableoid, oid, conname, "
8020 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8021 "convalidated "
8022 "FROM pg_catalog.pg_constraint "
8023 "WHERE contypid = $1 AND contype = 'c' "
8029 }
8050 {
8071 /*
8072 * Make the domain depend on the constraint, ensuring it won't be
8073 * output till any constraint dependencies are OK. If the constraint
8074 * has not been validated, it's going to be dumped after the domain
8075 * anyway, so this doesn't matter.
8076 */
8080 }
8085 }
8087 /*
8088 * getRules
8089 * get basic information about every rule in the system
8090 */
8091 void
8093 {
8108 "tableoid, oid, rulename, "
8109 "ev_class AS ruletable, ev_type, is_instead, "
8110 "ev_enabled "
8111 "FROM pg_rewrite "
8129 {
8130 Oid ruletableoid;
8140 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
8148 {
8149 /*
8150 * If the table is a view or materialized view, force its ON
8151 * SELECT rule to be sorted before the view itself --- this
8152 * ensures that any dependencies for the rule affect the table's
8153 * positioning. Other rules are forced to appear after their
8154 * table.
8155 */
8159 {
8162 /* We'll merge the rule into CREATE VIEW, if possible */
8164 }
8165 else
8166 {
8170 }
8171 }
8172 else
8174 }
8179 }
8181 /*
8182 * getTriggers
8183 * get information about every trigger on a dumpable table
8184 *
8185 * Note: trigger data is not returned directly to the caller, but it
8186 * does get entered into the DumpableObject tables.
8187 */
8188 void
8190 {
8198 i_oid,
8199 i_tgrelid,
8200 i_tgname,
8201 i_tgenabled,
8202 i_tgispartition,
8203 i_tgdef;
8205 /*
8206 * We want to perform just one query against pg_trigger. However, we
8207 * mustn't try to select every row of the catalog and then sort it out on
8208 * the client side, because some of the server-side functions we need
8209 * would be unsafe to apply to tables we don't have lock on. Hence, we
8210 * build an array of the OIDs of tables we care about (and now have lock
8211 * on!), and use a WHERE clause to constrain which rows are selected.
8212 */
8215 {
8222 /* OK, we need info for this table */
8226 }
8230 {
8231 /*
8232 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8233 * result in non-forward-compatible dumps of WHEN clauses due to
8234 * under-parenthesization.
8235 *
8236 * NB: We need to see partition triggers in case the tgenabled flag
8237 * has been changed from the parent.
8238 */
8240 "SELECT t.tgrelid, t.tgname, "
8241 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8242 "t.tgenabled, t.tableoid, t.oid, "
8245 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8246 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8247 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
8248 "OR t.tgenabled != u.tgenabled) "
8251 }
8253 {
8254 /*
8255 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8256 * result in non-forward-compatible dumps of WHEN clauses due to
8257 * under-parenthesization.
8258 *
8259 * NB: We need to see tgisinternal triggers in partitions, in case the
8260 * tgenabled flag has been changed from the parent.
8261 */
8263 "SELECT t.tgrelid, t.tgname, "
8264 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8267 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8268 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8269 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
8272 }
8274 {
8275 /*
8276 * NB: We need to see tgisinternal triggers in partitions, in case the
8277 * tgenabled flag has been changed from the parent. No tgparentid in
8278 * version 11-12, so we have to match them via pg_depend.
8279 *
8280 * See above about pretty=true in pg_get_triggerdef.
8281 */
8283 "SELECT t.tgrelid, t.tgname, "
8284 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8285 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
8287 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8288 "LEFT JOIN pg_catalog.pg_depend AS d ON "
8289 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8290 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8291 " d.objid = t.oid "
8292 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
8293 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
8296 }
8297 else
8298 {
8299 /* See above about pretty=true in pg_get_triggerdef */
8301 "SELECT t.tgrelid, t.tgname, "
8302 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8303 "t.tgenabled, false as tgispartition, "
8304 "t.tableoid, t.oid "
8306 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8307 "WHERE NOT tgisinternal "
8310 }
8326 /*
8327 * Outer loop iterates once per table, not once per row. Incrementing of
8328 * j is handled by the inner loop.
8329 */
8332 {
8337 /* Count rows for this table */
8342 /*
8343 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8344 * order.
8345 */
8347 {
8351 }
8355 /* Save data for this table */
8360 {
8371 }
8372 }
8378 }
8380 /*
8381 * getEventTriggers
8382 * get information about event triggers
8383 */
8384 void
8386 {
8388 PQExpBuffer query;
8392 i_oid,
8393 i_evtname,
8394 i_evtevent,
8395 i_evtowner,
8396 i_evttags,
8397 i_evtfname,
8398 i_evtenabled;
8401 /* Before 9.3, there are no event triggers */
8408 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8409 "evtevent, evtowner, "
8410 "array_to_string(array("
8411 "select quote_literal(x) "
8412 " from unnest(evttags) as t(x)), ', ') as evttags, "
8413 "e.evtfoid::regproc as evtfname "
8414 "FROM pg_event_trigger e "
8433 {
8446 /* Decide whether we want to dump it */
8448 }
8453 }
8455 /*
8456 * getProcLangs
8457 * get basic information about every procedural language in the system
8458 *
8459 * NB: this must run after getFuncs() because we assume we can do
8460 * findFuncByOid().
8461 */
8462 void
8464 {
8482 "lanname, lanpltrusted, lanplcallfoid, "
8483 "laninline, lanvalidator, "
8484 "lanacl, "
8485 "acldefault('l', lanowner) AS acldefault, "
8486 "lanowner "
8487 "FROM pg_language "
8488 "WHERE lanispl "
8509 {
8526 /* Decide whether we want to dump it */
8529 /* Mark whether language has an ACL */
8532 }
8537 }
8539 /*
8540 * getCasts
8541 * get basic information about most casts in the system
8542 *
8543 * Skip casts from a range to its multirange, since we'll create those
8544 * automatically.
8545 */
8546 void
8548 {
8563 {
8565 "castsource, casttarget, castfunc, castcontext, "
8566 "castmethod "
8567 "FROM pg_cast c "
8568 "WHERE NOT EXISTS ( "
8569 "SELECT 1 FROM pg_range r "
8570 "WHERE c.castsource = r.rngtypid "
8571 "AND c.casttarget = r.rngmultitypid "
8572 ") "
8574 }
8575 else
8576 {
8578 "castsource, casttarget, castfunc, castcontext, "
8579 "castmethod "
8581 }
8598 {
8599 PQExpBufferData namebuf;
8613 /*
8614 * Try to name cast as concatenation of typnames. This is only used
8615 * for purposes of sorting. If we fail to find either type, the name
8616 * will be an empty string.
8617 */
8626 /* Decide whether we want to dump it */
8628 }
8633 }
8637 {
8638 PQExpBuffer query;
8650 }
8652 /*
8653 * getTransforms
8654 * get basic information about every transform in the system
8655 */
8656 void
8658 {
8662 PQExpBuffer query;
8671 /* Transforms didn't exist pre-9.5 */
8678 "trftype, trflang, trffromsql::oid, trftosql::oid "
8679 "FROM pg_transform "
8696 {
8697 PQExpBufferData namebuf;
8710 /*
8711 * Try to name transform as concatenation of type and language name.
8712 * This is only used for purposes of sorting. If we fail to find
8713 * either, the name will be an empty string.
8714 */
8724 /* Decide whether we want to dump it */
8726 }
8731 }
8733 /*
8734 * getTableAttrs -
8735 * for each interesting table, read info about its attributes
8736 * (names, types, default values, CHECK constraints, etc)
8737 *
8738 * modifies tblinfo
8739 */
8740 void
8742 {
8773 /*
8774 * We want to perform just one query against pg_attribute, and then just
8775 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
8776 * (for CHECK constraints and for NOT NULL constraints). However, we
8777 * mustn't try to select every row of those catalogs and then sort it out
8778 * on the client side, because some of the server-side functions we need
8779 * would be unsafe to apply to tables we don't have lock on. Hence, we
8780 * build an array of the OIDs of tables we care about (and now have lock
8781 * on!), and use a WHERE clause to constrain which rows are selected.
8782 */
8786 {
8789 /* Don't bother to collect info for sequences */
8793 /* Don't bother with uninteresting tables, either */
8797 /* OK, we need info for this table */
8803 {
8804 /* Also make a list of the ones with check constraints */
8808 }
8809 }
8813 /*
8814 * Find all the user attributes and their types.
8815 *
8816 * Since we only want to dump COLLATE clauses for attributes whose
8817 * collation is different from their type's default, we use a CASE here to
8818 * suppress uninteresting attcollations cheaply.
8819 */
8835 "CASE WHEN a.attcollation <> t.typcollation "
8837 "pg_catalog.array_to_string(ARRAY("
8838 "SELECT pg_catalog.quote_ident(option_name) || "
8839 "' ' || pg_catalog.quote_literal(option_value) "
8840 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
8841 "ORDER BY option_name"
8844 /*
8845 * Find out any NOT NULL markings for each column. In 18 and up we read
8846 * pg_constraint to obtain the constraint name. notnull_noinherit is set
8847 * according to the NO INHERIT property. For versions prior to 18, we
8848 * store an empty string as the name when a constraint is marked as
8849 * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
8850 * without a name); also, such cases are never NO INHERIT.
8851 *
8852 * We track in notnull_islocal whether the constraint was defined directly
8853 * in this table or via an ancestor, for binary upgrade. flagInhAttrs
8854 * might modify this later for servers older than 18; it's also in charge
8855 * of determining the correct inhcount.
8856 */
8862 else
8871 else
8878 else
8884 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
8886 else
8893 else
8897 /* need left join to pg_type to not fail on dropped columns ... */
8900 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
8901 "LEFT JOIN pg_catalog.pg_type t "
8905 /*
8906 * In versions 18 and up, we need pg_constraint for explicit NOT NULL
8907 * entries. Also, we need to know if the NOT NULL for each column is
8908 * backing a primary key.
8909 */
8912 " LEFT JOIN pg_catalog.pg_constraint co ON "
8914 " AND co.contype = 'n' AND "
8948 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
8952 /*
8953 * Outer loop iterates once per table, not once per row. Incrementing of
8954 * r is handled by the inner loop.
8955 */
8958 {
8964 /* Count rows for this table */
8969 /*
8970 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8971 * order.
8972 */
8974 {
8978 }
8981 /* cross-check that we only got requested tables */
8987 /* Save data for this table */
9012 {
9020 else
9026 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
9032 /* Handle not-null constraint name and flags */
9036 i_notnull_islocal);
9046 }
9049 {
9050 /* Collect OIDs of interesting tables that have defaults */
9054 }
9055 }
9059 /*
9060 * Now get info about column defaults. This is skipped for a data-only
9061 * dump, as it is only needed for table schemas.
9062 */
9064 {
9087 {
9094 /*
9095 * Locate the associated TableInfo; we rely on tblinfo[] being in
9096 * OID order.
9097 */
9099 {
9101 {
9105 }
9108 }
9114 /*
9115 * dropped columns shouldn't have defaults, but just in case,
9116 * ignore 'em
9117 */
9134 /*
9135 * Figure out whether the default/generation expression should be
9136 * dumped as part of the main CREATE TABLE (or similar) command or
9137 * as a separate ALTER TABLE (or similar) command. The preference
9138 * is to put it into the CREATE command, but in some cases that's
9139 * not possible.
9140 */
9142 {
9143 /*
9144 * Column generation expressions cannot be dumped separately,
9145 * because there is no syntax for it. By setting separate to
9146 * false here we prevent the "default" from being processed as
9147 * its own dumpable object. Later, flagInhAttrs() will mark
9148 * it as not to be dumped at all, if possible (that is, if it
9149 * can be inherited from a parent).
9150 */
9152 }
9154 {
9155 /*
9156 * Defaults on a VIEW must always be dumped as separate ALTER
9157 * TABLE commands.
9158 */
9160 }
9162 {
9163 /* column will be suppressed, print default separately */
9165 }
9166 else
9167 {
9169 }
9172 {
9173 /*
9174 * Mark the default as needing to appear before the table, so
9175 * that any dependencies it has must be emitted before the
9176 * CREATE TABLE. If this is not possible, we'll change to
9177 * "separate" mode while sorting dependencies.
9178 */
9181 }
9184 }
9187 }
9189 /*
9190 * Get info about table CHECK constraints. This is skipped for a
9191 * data-only dump, as it is only needed for table schemas.
9192 */
9194 {
9209 "SELECT c.tableoid, c.oid, conrelid, conname, "
9210 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9211 "conislocal, convalidated "
9214 "WHERE contype = 'c' "
9231 /* As above, this loop iterates once per table, not once per row */
9234 {
9239 /* Count rows for this table */
9244 /*
9245 * Locate the associated TableInfo; we rely on tblinfo[] being in
9246 * OID order.
9247 */
9249 {
9253 }
9258 {
9265 }
9270 {
9289 /*
9290 * An unvalidated constraint needs to be dumped separately, so
9291 * that potentially-violating existing data is loaded before
9292 * the constraint.
9293 */
9298 /*
9299 * Mark the constraint as needing to appear before the table
9300 * --- this is so that any other dependencies of the
9301 * constraint will be emitted before we try to create the
9302 * table. If the constraint is to be dumped separately, it
9303 * will be dumped after data is loaded anyway, so don't do it.
9304 * (There's an automatic dependency in the opposite direction
9305 * anyway, so don't need to add one manually here.)
9306 */
9311 /*
9312 * We will detect later whether the constraint must be split
9313 * out from the table definition.
9314 */
9315 }
9316 }
9319 }
9324 }
9326 /*
9327 * Based on the getTableAttrs query's row corresponding to one column, set
9328 * the name and flags to handle a not-null constraint for that column in
9329 * the tbinfo struct.
9330 *
9331 * Result row 'r' is for tbinfo's attribute 'j'.
9332 *
9333 * There are three possibilities:
9334 * 1) the column has no not-null constraints. In that case, ->notnull_constrs
9335 * (the constraint name) remains NULL.
9336 * 2) The column has a constraint with no name (this is the case when
9337 * constraints come from pre-18 servers). In this case, ->notnull_constrs
9338 * is set to the empty string; dumpTableSchema will print just "NOT NULL".
9339 * 3) The column has a constraint with a known name; in that case
9340 * notnull_constrs carries that name and dumpTableSchema will print
9341 * "CONSTRAINT the_name NOT NULL". However, if the name is the default
9342 * (table_column_not_null), there's no need to print that name in the dump,
9343 * so notnull_constrs is set to the empty string and it behaves as the case
9344 * above.
9345 *
9346 * In a child table that inherits from a parent already containing NOT NULL
9347 * constraints and the columns in the child don't have their own NOT NULL
9348 * declarations, we suppress printing constraints in the child: the
9349 * constraints are acquired at the point where the child is attached to the
9350 * parent. This is tracked in ->notnull_islocal (which is set in flagInhAttrs
9351 * for servers pre-18).
9352 *
9353 * Any of these constraints might have the NO INHERIT bit. If so we set
9354 * ->notnull_noinh and NO INHERIT will be printed by dumpTableSchema.
9355 *
9356 * In case 3 above, the name comparison is a bit of a hack; it actually fails
9357 * to do the right thing in all but the trivial case. However, the downside
9358 * of getting it wrong is simply that the name is printed rather than
9359 * suppressed, so it's not a big deal.
9360 */
9361 static void
9366 {
9369 /*
9370 * notnull_noinh is straight from the query result. notnull_islocal also,
9371 * though flagInhAttrs may change that one later in versions < 18.
9372 */
9376 /*
9377 * Determine a constraint name to use. If the column is not marked not-
9378 * null, we set NULL which cues ... to do nothing. An empty string says
9379 * to print an unnamed NOT NULL, and anything else is a constraint name to
9380 * use.
9381 */
9383 {
9384 /*
9385 * < 18 doesn't have not-null names, so an unnamed constraint is
9386 * sufficient.
9387 */
9390 else
9392 }
9393 else
9394 {
9397 else
9398 {
9399 /*
9400 * In binary upgrade of inheritance child tables, must have a
9401 * constraint name that we can UPDATE later.
9402 */
9406 {
9409 }
9410 else
9411 {
9414 /* XXX should match ChooseConstraintName better */
9420 else
9421 {
9424 }
9425 }
9426 }
9427 }
9428 }
9430 /*
9431 * Test whether a column should be printed as part of table's CREATE TABLE.
9432 * Column number is zero-based.
9433 *
9434 * Normally this is always true, but it's false for dropped columns, as well
9435 * as those that were inherited without any local definition. (If we print
9436 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
9437 * For partitions, it's always true, because we want the partitions to be
9438 * created independently and ATTACH PARTITION used afterwards.
9439 *
9440 * In binary_upgrade mode, we must print all columns and fix the attislocal/
9441 * attisdropped state later, so as to keep control of the physical column
9442 * order.
9443 *
9444 * This function exists because there are scattered nonobvious places that
9445 * must be kept in sync with this decision.
9446 */
9447 bool
9449 {
9455 }
9458 /*
9459 * getTSParsers:
9460 * get information about all text search parsers in the system catalogs
9461 */
9462 void
9464 {
9468 PQExpBuffer query;
9482 /*
9483 * find all text search objects, including builtin ones; we filter out
9484 * system-defined objects at dump-out time.
9485 */
9488 "prsstart::oid, prstoken::oid, "
9489 "prsend::oid, prsheadline::oid, prslextype::oid "
9509 {
9523 /* Decide whether we want to dump it */
9525 }
9530 }
9532 /*
9533 * getTSDictionaries:
9534 * get information about all text search dictionaries in the system catalogs
9535 */
9536 void
9538 {
9542 PQExpBuffer query;
9555 "dictnamespace, dictowner, "
9556 "dicttemplate, dictinitoption "
9574 {
9586 else
9589 /* Decide whether we want to dump it */
9591 }
9596 }
9598 /*
9599 * getTSTemplates:
9600 * get information about all text search templates in the system catalogs
9601 */
9602 void
9604 {
9608 PQExpBuffer query;
9620 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
9637 {
9648 /* Decide whether we want to dump it */
9650 }
9655 }
9657 /*
9658 * getTSConfigurations:
9659 * get information about all text search configurations
9660 */
9661 void
9663 {
9667 PQExpBuffer query;
9679 "cfgnamespace, cfgowner, cfgparser "
9696 {
9707 /* Decide whether we want to dump it */
9709 }
9714 }
9716 /*
9717 * getForeignDataWrappers:
9718 * get information about all foreign-data wrappers in the system catalogs
9719 */
9720 void
9722 {
9726 PQExpBuffer query;
9741 "fdwowner, "
9742 "fdwhandler::pg_catalog.regproc, "
9743 "fdwvalidator::pg_catalog.regproc, "
9744 "fdwacl, "
9745 "acldefault('F', fdwowner) AS acldefault, "
9746 "array_to_string(ARRAY("
9747 "SELECT quote_ident(option_name) || ' ' || "
9748 "quote_literal(option_value) "
9749 "FROM pg_options_to_table(fdwoptions) "
9750 "ORDER BY option_name"
9771 {
9787 /* Decide whether we want to dump it */
9790 /* Mark whether FDW has an ACL */
9793 }
9798 }
9800 /*
9801 * getForeignServers:
9802 * get information about all foreign servers in the system catalogs
9803 */
9804 void
9806 {
9810 PQExpBuffer query;
9826 "srvowner, "
9827 "srvfdw, srvtype, srvversion, srvacl, "
9828 "acldefault('S', srvowner) AS acldefault, "
9829 "array_to_string(ARRAY("
9830 "SELECT quote_ident(option_name) || ' ' || "
9831 "quote_literal(option_value) "
9832 "FROM pg_options_to_table(srvoptions) "
9833 "ORDER BY option_name"
9855 {
9872 /* Decide whether we want to dump it */
9875 /* Servers have user mappings */
9878 /* Mark whether server has an ACL */
9881 }
9886 }
9888 /*
9889 * getDefaultACLs:
9890 * get information about all default ACL information in the system catalogs
9891 */
9892 void
9894 {
9897 PQExpBuffer query;
9907 ntups;
9911 /*
9912 * Global entries (with defaclnamespace=0) replace the hard-wired default
9913 * ACL for their object type. We should dump them as deltas from the
9914 * default ACL, since that will be used as a starting point for
9915 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
9916 * non-global entries can only add privileges not revoke them. We must
9917 * dump those as-is (i.e., as deltas from an empty ACL).
9918 *
9919 * We can use defaclobjtype as the object type for acldefault(), except
9920 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
9921 * 's'.
9922 */
9924 "SELECT oid, tableoid, "
9925 "defaclrole, "
9926 "defaclnamespace, "
9927 "defaclobjtype, "
9928 "defaclacl, "
9929 "CASE WHEN defaclnamespace = 0 THEN "
9930 "acldefault(CASE WHEN defaclobjtype = 'S' "
9932 "defaclrole) ELSE '{}' END AS acldefault "
9950 {
9957 /* cheesy ... is it worth coming up with a better object name? */
9962 else
9972 /* Default ACLs are ACLs, of course */
9975 /* Decide whether we want to dump it */
9977 }
9982 }
9984 /*
9985 * getRoleName -- look up the name of a role, given its OID
9986 *
9987 * In current usage, we don't expect failures, so error out for a bad OID.
9988 */
9991 {
9994 /*
9995 * Do binary search to find the appropriate item.
9996 */
9998 {
10003 {
10010 else
10012 }
10013 }
10017 }
10019 /*
10020 * collectRoleNames --
10021 *
10022 * Construct a table of all known roles.
10023 * The table is sorted by OID for speed in lookup.
10024 */
10025 static void
10027 {
10041 {
10044 }
10047 }
10049 /*
10050 * getAdditionalACLs
10051 *
10052 * We have now created all the DumpableObjects, and collected the ACL data
10053 * that appears in the directly-associated catalog entries. However, there's
10054 * more ACL-related info to collect. If any of a table's columns have ACLs,
10055 * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
10056 * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
10057 * Also, in versions having the pg_init_privs catalog, read that and load the
10058 * information into the relevant DumpableObjects.
10059 */
10060 static void
10062 {
10066 i;
10068 /* Check for per-column ACLs */
10070 "SELECT DISTINCT attrelid FROM pg_attribute "
10077 {
10082 /* OK to ignore tables we haven't got a DumpableObject for */
10084 {
10087 }
10088 }
10091 /* Fetch initial-privileges data */
10093 {
10095 "SELECT objoid, classoid, objsubid, privtype, initprivs "
10102 {
10108 CatalogId objId;
10114 /* OK to ignore entries we haven't got a DumpableObject for */
10116 {
10117 /* Cope with sub-object initprivs */
10119 {
10121 {
10122 /* For a column initprivs, set the table's ACL flags */
10125 }
10126 else
10130 }
10132 /*
10133 * We ignore any pg_init_privs.initprivs entry for the public
10134 * schema, as explained in getNamespaces().
10135 */
10140 /* Else it had better be of a type we think has ACLs */
10149 {
10154 }
10155 else
10158 }
10159 }
10161 }
10164 }
10166 /*
10167 * dumpCommentExtended --
10168 *
10169 * This routine is used to dump any comments associated with the
10170 * object handed to this routine. The routine takes the object type
10171 * and object name (ready to print, except for schema decoration), plus
10172 * the namespace and owner of the object (for labeling the ArchiveEntry),
10173 * plus catalog ID and subid which are the lookup key for pg_description,
10174 * plus the dump ID for the object (for setting a dependency).
10175 * If a matching pg_description entry is found, it is dumped.
10176 *
10177 * Note: in some cases, such as comments for triggers and rules, the "type"
10178 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
10179 * but it doesn't seem worth complicating the API for all callers to make
10180 * it cleaner.
10181 *
10182 * Note: although this routine takes a dumpId for dependency purposes,
10183 * that purpose is just to mark the dependency in the emitted dump file
10184 * for possible future use by pg_restore. We do NOT use it for determining
10185 * ordering of the comment in the dump file, because this routine is called
10186 * after dependency sorting occurs. This routine should be called just after
10187 * calling ArchiveEntry() for the specified object.
10188 */
10189 static void
10195 {
10200 /* do nothing, if --no-comments is supplied */
10204 /* Comments are schema not data ... except LO comments are data */
10206 {
10209 }
10210 else
10211 {
10212 /* We do dump LO comments in binary-upgrade mode */
10215 }
10217 /* Search for comments associated with catalogId, using table */
10221 /* Is there one matching the subid? */
10223 {
10226 comments++;
10227 ncomments--;
10228 }
10231 {
10234 /*
10235 * initdb creates this object with a comment. Skip dumping the
10236 * initdb-provided comment, which would complicate matters for
10237 * non-superuser use of pg_dump. When the DBA has removed initdb's
10238 * comment, replicate that.
10239 */
10241 {
10244 }
10247 }
10249 /* If a comment exists, build COMMENT ON statement */
10251 {
10264 /*
10265 * We mark comments as SECTION_NONE because they really belong in the
10266 * same section as their parent, whether that is pre-data or
10267 * post-data.
10268 */
10281 }
10282 }
10284 /*
10285 * dumpComment --
10286 *
10287 * Typical simplification of the above function.
10288 */
10294 {
10297 }
10299 /*
10300 * dumpTableComment --
10301 *
10302 * As above, but dump comments for both the specified table (or view)
10303 * and its columns.
10304 */
10305 static void
10308 {
10312 PQExpBuffer query;
10313 PQExpBuffer tag;
10315 /* do nothing, if --no-comments is supplied */
10319 /* Comments are SCHEMA not data */
10323 /* Search for comments associated with relation, using table */
10328 /* If comments exist, build COMMENT ON statements */
10336 {
10341 {
10361 }
10363 {
10386 }
10388 comments++;
10389 ncomments--;
10390 }
10394 }
10396 /*
10397 * findComments --
10398 *
10399 * Find the comment(s), if any, associated with the given object. All the
10400 * objsubid values associated with the given classoid/objoid are found with
10401 * one search.
10402 */
10403 static int
10405 {
10411 /*
10412 * Do binary search to find some item matching the object.
10413 */
10417 {
10428 else
10430 }
10433 {
10436 }
10438 /*
10439 * Now determine how many items match the object. The search loop
10440 * invariant still holds: only items between low and high inclusive could
10441 * match.
10442 */
10445 {
10449 middle--;
10450 nmatch++;
10451 }
10457 {
10461 middle++;
10462 nmatch++;
10463 }
10466 }
10468 /*
10469 * collectComments --
10470 *
10471 * Construct a table of all comments available for database objects;
10472 * also set the has-comment component flag for each relevant object.
10473 *
10474 * We used to do per-object queries for the comments, but it's much faster
10475 * to pull them all over at once, and on most databases the memory cost
10476 * isn't high.
10477 *
10478 * The table is sorted by classoid/objid/objsubid for speed in lookup.
10479 */
10480 static void
10482 {
10484 PQExpBuffer query;
10496 "FROM pg_catalog.pg_description "
10501 /* Construct lookup table containing OIDs in numeric form */
10515 {
10516 CatalogId objId;
10523 /* We needn't remember comments that don't match any dumpable object */
10531 /*
10532 * Comments on columns of composite types are linked to the type's
10533 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
10534 * in the type's own DumpableObject.
10535 */
10538 {
10544 }
10545 else
10552 ncomments++;
10553 }
10557 }
10559 /*
10560 * dumpDumpableObject
10561 *
10562 * This routine and its subsidiaries are responsible for creating
10563 * ArchiveEntries (TOC objects) for each object to be dumped.
10564 */
10565 static void
10567 {
10568 /*
10569 * Clear any dump-request bits for components that don't exist for this
10570 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
10571 * request for every kind of object.)
10572 */
10575 /* Now, short-circuit if there's nothing to be done here. */
10580 {
10669 /* table rowtypes and array types are never dumped separately */
10697 {
10716 /*
10717 * Set the TocEntry's dataLength in case we are doing a
10718 * parallel dump and want to order dump jobs by table size.
10719 * (We need some size estimate for every TocEntry with a
10720 * DataDumper function.) We don't currently have any cheap
10721 * way to estimate the size of LOs, but fortunately it doesn't
10722 * matter too much as long as we get large batches of LOs
10723 * processed reasonably early. Assume 8K per blob.
10724 */
10726 }
10749 /* never dumped, nothing to do */
10751 }
10752 }
10754 /*
10755 * dumpNamespace
10756 * writes out to fout the queries to recreate a user-defined namespace
10757 */
10758 static void
10760 {
10762 PQExpBuffer q;
10763 PQExpBuffer delq;
10766 /* Do nothing if not dumping schema */
10776 {
10779 }
10780 else
10781 {
10782 /* see selectDumpableNamespace() */
10787 }
10802 /* Dump Schema Comments and Security Labels */
10804 {
10812 initdb_comment);
10813 }
10829 }
10831 /*
10832 * dumpExtension
10833 * writes out to fout the queries to recreate an extension
10834 */
10835 static void
10837 {
10839 PQExpBuffer q;
10840 PQExpBuffer delq;
10843 /* Do nothing if not dumping schema */
10855 {
10856 /*
10857 * In a regular dump, we simply create the extension, intentionally
10858 * not specifying a version, so that the destination installation's
10859 * default version is used.
10860 *
10861 * Use of IF NOT EXISTS here is unlike our behavior for other object
10862 * types; but there are various scenarios in which it's convenient to
10863 * manually create the desired extension before restoring, so we
10864 * prefer to allow it to exist already.
10865 */
10868 }
10869 else
10870 {
10871 /*
10872 * In binary-upgrade mode, it's critical to reproduce the state of the
10873 * database exactly, so our procedure is to create an empty extension,
10874 * restore all the contained objects normally, and add them to the
10875 * extension one by one. This function performs just the first of
10876 * those steps. binary_upgrade_extension_member() takes care of
10877 * adding member objects as they're created.
10878 */
10882 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
10884 /*
10885 * We unconditionally create the extension, so we must drop it if it
10886 * exists. This could happen if the user deleted 'plpgsql' and then
10887 * readded it, causing its oid to be greater than g_last_builtin_oid.
10888 */
10901 /*
10902 * Note that we're pushing extconfig (an OID array) back into
10903 * pg_extension exactly as-is. This is OK because pg_class OIDs are
10904 * preserved in binary upgrade.
10905 */
10908 else
10913 else
10919 {
10924 {
10928 }
10929 }
10932 }
10942 /* Dump Extension Comments and Security Labels */
10957 }
10959 /*
10960 * dumpType
10961 * writes out to fout the queries to recreate a user-defined type
10962 */
10963 static void
10965 {
10968 /* Do nothing if not dumping schema */
10972 /* Dump out in proper style */
10985 else
10988 }
10990 /*
10991 * dumpEnumType
10992 * writes out to fout the queries to recreate a user-defined enum type
10993 */
10994 static void
10996 {
11003 i;
11004 Oid enum_oid;
11012 {
11013 /* Set up query for enum-specific details */
11016 "SELECT oid, enumlabel "
11017 "FROM pg_catalog.pg_enum "
11018 "WHERE enumtypid = $1 "
11024 }
11037 /*
11038 * CASCADE shouldn't be required here as for normal types since the I/O
11039 * functions are generic and do not get dropped.
11040 */
11049 qualtypname);
11052 {
11055 /* Labels with server-assigned oids */
11057 {
11063 }
11064 }
11069 {
11073 /* Labels with dump-assigned (preserved) oids */
11075 {
11083 enum_oid);
11087 }
11088 }
11105 /* Dump Type Comments and Security Labels */
11128 }
11130 /*
11131 * dumpRangeType
11132 * writes out to fout the queries to recreate a user-defined range type
11133 */
11134 static void
11136 {
11142 Oid collationOid;
11148 {
11149 /* Set up query for range-specific details */
11159 else
11164 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
11165 "opc.opcname AS opcname, "
11166 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
11167 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
11168 "opc.opcdefault, "
11169 "CASE WHEN rngcollation = st.typcollation THEN 0 "
11170 " ELSE rngcollation END AS collation, "
11171 "rngcanonical, rngsubdiff "
11172 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
11173 " pg_catalog.pg_opclass opc "
11174 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
11180 }
11191 /*
11192 * CASCADE shouldn't be required here as for normal types since the I/O
11193 * functions are generic and do not get dropped.
11194 */
11203 qualtypname);
11212 /* print subtype_opclass only if not default for subtype */
11214 {
11221 }
11225 {
11231 }
11258 /* Dump Type Comments and Security Labels */
11281 }
11283 /*
11284 * dumpUndefinedType
11285 * writes out to fout the queries to recreate a !typisdefined type
11286 *
11287 * This is a shell type, but we use different terminology to distinguish
11288 * this case from where we have to emit a shell type definition to break
11289 * circular dependencies. An undefined type shouldn't ever have anything
11290 * depending on it.
11291 */
11292 static void
11294 {
11312 qualtypname);
11329 /* Dump Type Comments and Security Labels */
11350 }
11352 /*
11353 * dumpBaseType
11354 * writes out to fout the queries to recreate a user-defined base type
11355 */
11356 static void
11358 {
11375 Oid typreceiveoid;
11376 Oid typsendoid;
11377 Oid typmodinoid;
11378 Oid typmodoutoid;
11379 Oid typanalyzeoid;
11380 Oid typsubscriptoid;
11392 {
11393 /* Set up query for type-specific details */
11396 "SELECT typlen, "
11397 "typinput, typoutput, typreceive, typsend, "
11398 "typreceive::pg_catalog.oid AS typreceiveoid, "
11399 "typsend::pg_catalog.oid AS typsendoid, "
11400 "typanalyze, "
11401 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
11402 "typdelim, typbyval, typalign, typstorage, "
11403 "typmodin, typmodout, "
11404 "typmodin::pg_catalog.oid AS typmodinoid, "
11405 "typmodout::pg_catalog.oid AS typmodoutoid, "
11406 "typcategory, typispreferred, "
11407 "(typcollation <> 0) AS typcollatable, "
11412 "typsubscript, "
11414 else
11424 }
11457 {
11460 }
11461 else
11467 /*
11468 * The reason we include CASCADE is that the circular dependency between
11469 * the type and its I/O functions makes it impossible to drop the type any
11470 * other way.
11471 */
11474 /*
11475 * We might already have a shell type, but setting pg_type_oid is
11476 * harmless, and in any case we'd better set the array type OID.
11477 */
11486 qualtypname,
11489 /* regproc result is sufficiently quoted already */
11507 {
11511 else
11513 }
11521 zeroIsError));
11524 {
11527 }
11533 {
11536 }
11576 /* Dump Type Comments and Security Labels */
11599 }
11601 /*
11602 * dumpDomain
11603 * writes out to fout the queries to recreate a user-defined domain
11604 */
11605 static void
11607 {
11619 Oid typcollation;
11623 {
11624 /* Set up query for domain-specific details */
11629 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
11630 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
11631 "t.typdefault, "
11632 "CASE WHEN t.typcollation <> u.typcollation "
11633 "THEN t.typcollation ELSE 0 END AS typcollation "
11634 "FROM pg_catalog.pg_type t "
11635 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
11641 }
11654 {
11657 }
11658 else
11673 qualtypname,
11674 typdefn);
11676 /* Print collation only if different from base type's collation */
11678 {
11684 }
11690 {
11694 else
11696 }
11700 /*
11701 * Add any CHECK constraints for the domain
11702 */
11704 {
11710 }
11731 /* Dump Domain Comments and Security Labels */
11748 /* Dump any per-constraint comments */
11750 {
11764 }
11771 }
11773 /*
11774 * dumpCompositeType
11775 * writes out to fout the queries to recreate a user-defined stand-alone
11776 * composite type
11777 */
11778 static void
11780 {
11800 {
11801 /*
11802 * Set up query for type-specific details.
11803 *
11804 * Since we only want to dump COLLATE clauses for attributes whose
11805 * collation is different from their type's default, we use a CASE
11806 * here to suppress uninteresting attcollations cheaply. atttypid
11807 * will be 0 for dropped columns; collation does not matter for those.
11808 */
11811 "SELECT a.attname, a.attnum, "
11812 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
11813 "a.attlen, a.attalign, a.attisdropped, "
11814 "CASE WHEN a.attcollation <> at.typcollation "
11815 "THEN a.attcollation ELSE 0 END AS attcollation "
11816 "FROM pg_catalog.pg_type ct "
11817 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
11818 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
11819 "WHERE ct.oid = $1 "
11825 }
11843 {
11848 }
11854 qualtypname);
11858 {
11864 Oid attcollation;
11876 /* Format properly if not first attr */
11882 {
11885 /* Add collation if not default for the column type */
11887 {
11894 }
11895 }
11896 else
11897 {
11898 /*
11899 * This is a dropped attribute and we're in binary_upgrade mode.
11900 * Insert a placeholder for it in the CREATE TYPE command, and set
11901 * length and alignment with direct UPDATE to the catalogs
11902 * afterwards. See similar code in dumpTableSchema().
11903 */
11906 /* stash separately for insertion after the CREATE TYPE */
11910 "SET attlen = %s, "
11919 qualtypname);
11922 }
11923 }
11945 /* Dump Type Comments and Security Labels */
11962 /* Dump any per-column comments */
11973 }
11975 /*
11976 * dumpCompositeTypeColComments
11977 * writes out to fout the queries to recreate comments on the columns of
11978 * a user-defined stand-alone composite type.
11979 *
11980 * The caller has already made a query to collect the names and attnums
11981 * of the type's columns, so we just pass that result into here rather
11982 * than reading them again.
11983 */
11984 static void
11987 {
11990 PQExpBuffer query;
11991 PQExpBuffer target;
11998 /* do nothing, if --no-comments is supplied */
12002 /* Search for comments associated with type's pg_class OID */
12006 /* If no comments exist, we're done */
12010 /* Build COMMENT ON statements */
12019 {
12024 {
12027 {
12030 }
12031 }
12033 {
12057 }
12059 comments++;
12060 ncomments--;
12061 }
12065 }
12067 /*
12068 * dumpShellType
12069 * writes out to fout the queries to create a shell type
12070 *
12071 * We dump a shell definition in advance of the I/O functions for the type.
12072 */
12073 static void
12075 {
12077 PQExpBuffer q;
12079 /* Do nothing if not dumping schema */
12085 /*
12086 * Note the lack of a DROP command for the shell type; any required DROP
12087 * is driven off the base type entry, instead. This interacts with
12088 * _printTocEntry()'s use of the presence of a DROP command to decide
12089 * whether an entry needs an ALTER OWNER command. We don't want to alter
12090 * the shell type's owner immediately on creation; that should happen only
12091 * after it's filled in, otherwise the backend complains.
12092 */
12112 }
12114 /*
12115 * dumpProcLang
12116 * writes out to fout the queries to recreate a user-defined
12117 * procedural language
12118 */
12119 static void
12121 {
12123 PQExpBuffer defqry;
12124 PQExpBuffer delqry;
12131 /* Do nothing if not dumping schema */
12135 /*
12136 * Try to find the support function(s). It is not an error if we don't
12137 * find them --- if the functions are in the pg_catalog schema, as is
12138 * standard in 8.1 and up, then we won't have loaded them. (In this case
12139 * we will emit a parameterless CREATE LANGUAGE command, which will
12140 * require PL template knowledge in the backend to reload.)
12141 */
12148 {
12152 }
12155 {
12159 }
12161 /*
12162 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
12163 * parameters. Otherwise, we'll write a parameterless command, which will
12164 * be interpreted as CREATE EXTENSION.
12165 */
12176 qlanname);
12179 {
12182 qlanname);
12191 }
12192 else
12193 {
12194 /*
12195 * If not dumping parameters, then use CREATE OR REPLACE so that the
12196 * command will not fail if the language is preinstalled in the target
12197 * database.
12198 *
12199 * Modern servers will interpret this as CREATE EXTENSION IF NOT
12200 * EXISTS; perhaps we should emit that instead? But it might just add
12201 * confusion.
12202 */
12204 qlanname);
12205 }
12220 ));
12222 /* Dump Proc Lang Comments and Security Labels */
12242 }
12244 /*
12245 * format_function_arguments: generate function name and argument list
12246 *
12247 * This is used when we can rely on pg_get_function_arguments to format
12248 * the argument list. Note, however, that pg_get_function_arguments
12249 * does not special-case zero-argument aggregates.
12250 */
12253 {
12254 PQExpBufferData fn;
12260 else
12263 }
12265 /*
12266 * format_function_signature: generate function name and argument list
12267 *
12268 * Only a minimal list of input argument types is generated; this is
12269 * sufficient to reference the function, but not to define it.
12270 *
12271 * If honor_quotes is false then the function name is never quoted.
12272 * This is appropriate for use in TOC tags, but not in SQL commands.
12273 */
12276 {
12277 PQExpBufferData fn;
12283 else
12286 {
12292 zeroIsError));
12293 }
12296 }
12299 /*
12300 * dumpFunc:
12301 * dump out one function
12302 */
12303 static void
12305 {
12307 PQExpBuffer query;
12308 PQExpBuffer q;
12309 PQExpBuffer delqry;
12310 PQExpBuffer asPart;
12339 /* Do nothing if not dumping schema */
12349 {
12350 /* Set up query for function-specific details */
12374 else
12381 else
12388 else
12395 else
12402 else
12408 "WHERE p.oid = $1 "
12414 }
12424 {
12428 }
12429 else
12430 {
12434 }
12451 /*
12452 * See backend/commands/functioncmds.c for details of how the 'AS' clause
12453 * is used.
12454 */
12456 {
12458 }
12460 {
12464 {
12467 /*
12468 * where we have bin, use dollar quoting if allowed and src
12469 * contains quote or backslash; else use regular quoting.
12470 */
12474 else
12476 }
12477 }
12478 else
12479 {
12481 /* with no bin, dollar quote src unconditionally if allowed */
12484 else
12486 }
12489 {
12492 }
12493 else
12494 {
12497 }
12506 funcsig);
12510 else
12517 keyword,
12520 funcsig);
12526 else
12530 zeroIsError));
12535 {
12542 {
12547 }
12550 }
12556 {
12564 }
12575 /*
12576 * COST and ROWS are emitted only if present and not default, so as not to
12577 * break backwards-compatibility of the dump without need. Keep this code
12578 * in sync with the defaults in functioncmds.c.
12579 */
12581 {
12583 {
12584 /* default cost is 1 */
12587 }
12588 else
12589 {
12590 /* default cost is 100 */
12593 }
12594 }
12600 {
12601 /* We rely on regprocout to provide quoting and qualification */
12603 }
12606 {
12614 }
12617 {
12618 /* we feel free to scribble on configitems[] here */
12628 /*
12629 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
12630 * by flatten_set_variable_args() before they were put into the
12631 * proconfig array. However, because the quoting rules used there
12632 * aren't exactly like SQL's, we have to break the list value apart
12633 * and then quote the elements as string literals. (The elements may
12634 * be double-quoted as-is, but we can't just feed them to the SQL
12635 * parser; it would do the wrong thing with elements that are
12636 * zero-length or longer than NAMEDATALEN.)
12637 *
12638 * Variables that are not so marked should just be emitted as simple
12639 * string literals. If the variable is not known to
12640 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
12641 * to use GUC_LIST_QUOTE for extension variables.
12642 */
12644 {
12648 /* Parse string into list of identifiers */
12649 /* this shouldn't fail really */
12651 {
12653 {
12657 }
12658 }
12660 }
12661 else
12663 }
12669 qual_funcsig);
12687 /* Dump Function Comments and Security Labels */
12715 }
12718 /*
12719 * Dump a user-defined cast
12720 */
12721 static void
12723 {
12725 PQExpBuffer defqry;
12726 PQExpBuffer delqry;
12727 PQExpBuffer labelq;
12728 PQExpBuffer castargs;
12733 /* Do nothing if not dumping schema */
12737 /* Cannot dump if we don't have the cast function's info */
12739 {
12744 }
12760 {
12769 {
12772 /*
12773 * Always qualify the function name (format_function_signature
12774 * won't qualify it).
12775 */
12779 }
12780 else
12785 }
12811 /* Dump Cast Comments */
12821 }
12823 /*
12824 * Dump a transform
12825 */
12826 static void
12828 {
12830 PQExpBuffer defqry;
12831 PQExpBuffer delqry;
12832 PQExpBuffer labelq;
12833 PQExpBuffer transformargs;
12839 /* Do nothing if not dumping schema */
12843 /* Cannot dump if we don't have the transform functions' info */
12845 {
12850 }
12852 {
12857 }
12874 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
12877 {
12879 {
12882 /*
12883 * Always qualify the function name (format_function_signature
12884 * won't qualify it).
12885 */
12889 }
12890 else
12892 }
12895 {
12900 {
12903 /*
12904 * Always qualify the function name (format_function_signature
12905 * won't qualify it).
12906 */
12910 }
12911 else
12913 }
12937 /* Dump Transform Comments */
12948 }
12951 /*
12952 * dumpOpr
12953 * write out a single operator definition
12954 */
12955 static void
12957 {
12959 PQExpBuffer query;
12960 PQExpBuffer q;
12961 PQExpBuffer delq;
12962 PQExpBuffer oprid;
12963 PQExpBuffer details;
12988 /* Do nothing if not dumping schema */
12992 /*
12993 * some operators are invalid because they were the result of user
12994 * defining operators before commutators exist
12995 */
13006 {
13007 /* Set up query for operator-specific details */
13010 "SELECT oprkind, "
13011 "oprcode::pg_catalog.regprocedure, "
13012 "oprleft::pg_catalog.regtype, "
13013 "oprright::pg_catalog.regtype, "
13014 "oprcom, "
13015 "oprnegate, "
13016 "oprrest::pg_catalog.regprocedure, "
13017 "oprjoin::pg_catalog.regprocedure, "
13018 "oprcanmerge, oprcanhash "
13019 "FROM pg_catalog.pg_operator "
13025 }
13055 /* In PG14 upwards postfix operator support does not exist anymore. */
13058 oprcode);
13062 {
13065 }
13070 /*
13071 * right unary means there's a left arg and left unary means there's a
13072 * right arg. (Although the "r" case is dead code for PG14 and later,
13073 * continue to support it in case we're dumping from an old server.)
13074 */
13077 {
13080 }
13081 else
13086 {
13089 }
13090 else
13095 {
13098 }
13102 {
13105 }
13115 {
13118 }
13122 {
13125 }
13150 /* Dump Operator Comments */
13163 }
13165 /*
13166 * Convert a function reference obtained from pg_operator
13167 *
13168 * Returns allocated string of what to print, or NULL if function references
13169 * is InvalidOid. Returned string is expected to be free'd by the caller.
13170 *
13171 * The input is a REGPROCEDURE display; we have to strip the argument-types
13172 * part.
13173 */
13176 {
13181 /* In all cases "-" means a null reference */
13186 /* find non-double-quoted left paren */
13189 {
13191 {
13194 }
13197 }
13199 }
13201 /*
13202 * getFormattedOperatorName - retrieve the operator name for the
13203 * given operator OID (presented in string form).
13204 *
13205 * Returns an allocated string, or NULL if the given OID is invalid.
13206 * Caller is responsible for free'ing result string.
13207 *
13208 * What we produce has the format "OPERATOR(schema.oprname)". This is only
13209 * useful in commands where the operator's argument types can be inferred from
13210 * context. We always schema-qualify the name, though. The predecessor to
13211 * this code tried to skip the schema qualification if possible, but that led
13212 * to wrong results in corner cases, such as if an operator and its negator
13213 * are in different schemas.
13214 */
13217 {
13220 /* In all cases "0" means a null reference */
13226 {
13228 oproid);
13230 }
13235 }
13237 /*
13238 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
13239 *
13240 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
13241 * argument lists of these functions are predetermined. Note that the
13242 * caller should ensure we are in the proper schema, because the results
13243 * are search path dependent!
13244 */
13247 {
13261 }
13263 /*
13264 * dumpAccessMethod
13265 * write out a single access method definition
13266 */
13267 static void
13269 {
13271 PQExpBuffer q;
13272 PQExpBuffer delq;
13275 /* Do nothing if not dumping schema */
13287 {
13301 }
13306 qamname);
13320 /* Dump Access Method Comments */
13329 }
13331 /*
13332 * dumpOpclass
13333 * write out a single operator class definition
13334 */
13335 static void
13337 {
13339 PQExpBuffer query;
13340 PQExpBuffer q;
13341 PQExpBuffer delq;
13342 PQExpBuffer nameusing;
13378 /* Do nothing if not dumping schema */
13387 /* Get additional fields from the pg_opclass row */
13389 "opckeytype::pg_catalog.regtype, "
13390 "opcdefault, opcfamily, "
13391 "opfname AS opcfamilyname, "
13392 "nspname AS opcfamilynsp, "
13393 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
13394 "FROM pg_catalog.pg_opclass c "
13395 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
13396 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13410 /* opcintype may still be needed after we PQclear res */
13414 /* opcfamily will still be needed after we PQclear res */
13418 /* amname will still be needed after we PQclear res */
13426 /* Build the fixed portion of the CREATE command */
13432 opcintype,
13435 {
13439 }
13445 {
13447 opckeytype);
13449 }
13453 /*
13454 * Now fetch and print the OPERATOR entries (pg_amop rows).
13455 *
13456 * Print only those opfamily members that are tied to the opclass by
13457 * pg_depend entries.
13458 */
13461 "amopopr::pg_catalog.regoperator, "
13462 "opfname AS sortfamily, "
13463 "nspname AS sortfamilynsp "
13464 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13465 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13466 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13467 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13468 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13469 "AND refobjid = '%u'::pg_catalog.oid "
13470 "AND amopfamily = '%s'::pg_catalog.oid "
13473 opcfamily);
13485 {
13498 {
13502 }
13505 }
13509 /*
13510 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13511 *
13512 * Print only those opfamily members that are tied to the opclass by
13513 * pg_depend entries.
13514 *
13515 * We print the amproclefttype/amprocrighttype even though in most cases
13516 * the backend could deduce the right values, because of the corner case
13517 * of a btree sort support function for a cross-type comparison.
13518 */
13522 "amproc::pg_catalog.regprocedure, "
13523 "amproclefttype::pg_catalog.regtype, "
13524 "amprocrighttype::pg_catalog.regtype "
13525 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13526 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13527 "AND refobjid = '%u'::pg_catalog.oid "
13528 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13529 "AND objid = ap.oid "
13543 {
13560 }
13564 /*
13565 * If needComma is still false it means we haven't added anything after
13566 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
13567 * clause with the same datatype. This isn't sanctioned by the
13568 * documentation, but actually DefineOpClass will treat it as a no-op.
13569 */
13594 /* Dump Operator Class Comments */
13607 }
13609 /*
13610 * dumpOpfamily
13611 * write out a single operator family definition
13612 *
13613 * Note: this also dumps any "loose" operator members that aren't bound to a
13614 * specific opclass within the opfamily.
13615 */
13616 static void
13618 {
13620 PQExpBuffer query;
13621 PQExpBuffer q;
13622 PQExpBuffer delq;
13623 PQExpBuffer nameusing;
13649 /* Do nothing if not dumping schema */
13658 /*
13659 * Fetch only those opfamily members that are tied directly to the
13660 * opfamily by pg_depend entries.
13661 */
13663 "amopopr::pg_catalog.regoperator, "
13664 "opfname AS sortfamily, "
13665 "nspname AS sortfamilynsp "
13666 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13667 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13668 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13669 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13670 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13671 "AND refobjid = '%u'::pg_catalog.oid "
13672 "AND amopfamily = '%u'::pg_catalog.oid "
13682 "amproc::pg_catalog.regprocedure, "
13683 "amproclefttype::pg_catalog.regtype, "
13684 "amprocrighttype::pg_catalog.regtype "
13685 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13686 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13687 "AND refobjid = '%u'::pg_catalog.oid "
13688 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13689 "AND objid = ap.oid "
13695 /* Get additional fields from the pg_opfamily row */
13699 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
13700 "FROM pg_catalog.pg_opfamily "
13708 /* amname will still be needed after we PQclear res */
13716 /* Build the fixed portion of the CREATE command */
13724 /* Do we need an ALTER to add loose members? */
13726 {
13734 /*
13735 * Now fetch and print the OPERATOR entries (pg_amop rows).
13736 */
13745 {
13758 {
13762 }
13765 }
13767 /*
13768 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13769 */
13778 {
13789 amproc);
13792 }
13795 }
13816 /* Dump Operator Family Comments */
13829 }
13831 /*
13832 * dumpCollation
13833 * write out a single collation definition
13834 */
13835 static void
13837 {
13839 PQExpBuffer query;
13840 PQExpBuffer q;
13841 PQExpBuffer delq;
13856 /* Do nothing if not dumping schema */
13866 /* Get collation-specific details */
13871 "collprovider, "
13873 else
13875 "'c' AS collprovider, "
13881 else
13891 else
13898 else
13903 "collcollate, "
13904 "collctype "
13905 "FROM pg_catalog.pg_collation c "
13922 else
13927 else
13930 /*
13931 * Before version 15, collcollate and collctype were of type NAME and
13932 * non-nullable. Treat empty strings as NULL for consistency.
13933 */
13935 {
13940 }
13944 else
13949 else
13966 /* to allow dumping pg_catalog; not accepted on input */
13968 else
13970 collprovider);
13976 {
13980 /* no locale -- the default collation cannot be reloaded anyway */
13981 }
13983 {
13989 fout);
13990 }
13992 {
13994 {
14000 fout);
14001 }
14002 else
14003 {
14010 }
14013 {
14016 }
14017 }
14019 {
14024 {
14027 }
14028 else
14029 {
14034 }
14035 }
14036 else
14039 /*
14040 * For binary upgrade, carry over the collation version. For normal
14041 * dump/restore, omit the version, so that it is computed upon restore.
14042 */
14044 {
14049 {
14053 fout);
14054 }
14055 }
14074 /* Dump Collation Comments */
14086 }
14088 /*
14089 * dumpConversion
14090 * write out a single conversion definition
14091 */
14092 static void
14094 {
14096 PQExpBuffer query;
14097 PQExpBuffer q;
14098 PQExpBuffer delq;
14110 /* Do nothing if not dumping schema */
14120 /* Get conversion-specific details */
14122 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
14123 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
14124 "conproc, condefault "
14125 "FROM pg_catalog.pg_conversion c "
14150 /* regproc output is already sufficiently quoted */
14168 /* Dump Conversion Comments */
14180 }
14182 /*
14183 * format_aggregate_signature: generate aggregate name and argument list
14184 *
14185 * The argument type names are qualified if needed. The aggregate name
14186 * is never qualified.
14187 */
14190 {
14191 PQExpBufferData buf;
14197 else
14202 else
14203 {
14210 zeroIsError));
14212 }
14214 }
14216 /*
14217 * dumpAgg
14218 * write out a single aggregate definition
14219 */
14220 static void
14222 {
14224 PQExpBuffer query;
14225 PQExpBuffer q;
14226 PQExpBuffer delq;
14227 PQExpBuffer details;
14258 /* Do nothing if not dumping schema */
14268 {
14269 /* Set up query for aggregate-specific details */
14274 "SELECT "
14295 else
14314 else
14325 else
14331 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14332 "WHERE a.aggfnoid = p.oid "
14338 }
14371 {
14379 }
14383 /* identify default modify flag for aggkind (must match DefineAggregate) */
14384 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
14385 /* replace omitted flags for old versions */
14391 /* regproc and regtype output is already sufficiently quoted */
14396 {
14398 aggtransspace);
14399 }
14402 {
14405 }
14408 {
14410 aggfinalfn);
14414 {
14416 {
14430 }
14431 }
14432 }
14444 {
14446 aggmtransfn,
14447 aggminvtransfn,
14448 aggmtranstype);
14449 }
14452 {
14454 aggmtransspace);
14455 }
14458 {
14461 }
14464 {
14466 aggmfinalfn);
14470 {
14472 {
14486 }
14487 }
14488 }
14492 {
14494 aggsortconvop);
14496 }
14502 {
14510 }
14514 aggsig);
14536 /* Dump Aggregate Comments */
14549 /*
14550 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
14551 * command look like a function's GRANT; in particular this affects the
14552 * syntax for zero-argument aggregates and ordered-set aggregates.
14553 */
14574 }
14576 /*
14577 * dumpTSParser
14578 * write out a single text search parser
14579 */
14580 static void
14582 {
14584 PQExpBuffer q;
14585 PQExpBuffer delq;
14588 /* Do nothing if not dumping schema */
14629 /* Dump Parser Comments */
14638 }
14640 /*
14641 * dumpTSDictionary
14642 * write out a single text search dictionary
14643 */
14644 static void
14646 {
14648 PQExpBuffer q;
14649 PQExpBuffer delq;
14650 PQExpBuffer query;
14656 /* Do nothing if not dumping schema */
14666 /* Fetch name and namespace of the dictionary's template */
14668 "FROM pg_ts_template p, pg_namespace n "
14684 /* the dictinitoption can be dumped straight into the command */
14708 /* Dump Dictionary Comments */
14718 }
14720 /*
14721 * dumpTSTemplate
14722 * write out a single text search template
14723 */
14724 static void
14726 {
14728 PQExpBuffer q;
14729 PQExpBuffer delq;
14732 /* Do nothing if not dumping schema */
14767 /* Dump Template Comments */
14776 }
14778 /*
14779 * dumpTSConfig
14780 * write out a single text search configuration
14781 */
14782 static void
14784 {
14786 PQExpBuffer q;
14787 PQExpBuffer delq;
14788 PQExpBuffer query;
14794 i;
14798 /* Do nothing if not dumping schema */
14808 /* Fetch name and namespace of the config's parser */
14810 "FROM pg_ts_parser p, pg_namespace n "
14843 {
14849 {
14850 /* starting a new token type, so start a new command */
14855 /* tokenname needs quoting, dictname does NOT */
14858 }
14859 else
14861 }
14886 /* Dump Configuration Comments */
14896 }
14898 /*
14899 * dumpForeignDataWrapper
14900 * write out a single foreign-data wrapper definition
14901 */
14902 static void
14904 {
14906 PQExpBuffer q;
14907 PQExpBuffer delq;
14910 /* Do nothing if not dumping schema */
14920 qfdwname);
14934 qfdwname);
14939 NULL);
14950 /* Dump Foreign Data Wrapper Comments */
14956 /* Handle the ACL */
14966 }
14968 /*
14969 * dumpForeignServer
14970 * write out a foreign server definition
14971 */
14972 static void
14974 {
14976 PQExpBuffer q;
14977 PQExpBuffer delq;
14978 PQExpBuffer query;
14983 /* Do nothing if not dumping schema */
14993 /* look up the foreign-data wrapper */
14995 "FROM pg_foreign_data_wrapper w "
15003 {
15006 }
15008 {
15011 }
15022 qsrvname);
15037 /* Dump Foreign Server Comments */
15043 /* Handle the ACL */
15049 /* Dump user mappings */
15063 }
15065 /*
15066 * dumpUserMappings
15067 *
15068 * This routine is used to dump any user mappings associated with the
15069 * server handed to this routine. Should be called after ArchiveEntry()
15070 * for the server.
15071 */
15072 static void
15077 {
15078 PQExpBuffer q;
15079 PQExpBuffer delq;
15080 PQExpBuffer query;
15081 PQExpBuffer tag;
15093 /*
15094 * We read from the publicly accessible view pg_user_mappings, so as not
15095 * to fail if run by a non-superuser. Note that the view will show
15096 * umoptions as null if the user hasn't got privileges for the associated
15097 * server; this means that pg_dump will dump such a mapping, but with no
15098 * OPTIONS clause. A possible alternative is to skip such mappings
15099 * altogether, but it's not clear that that's an improvement.
15100 */
15102 "SELECT usename, "
15103 "array_to_string(ARRAY("
15104 "SELECT quote_ident(option_name) || ' ' || "
15105 "quote_literal(option_value) "
15106 "FROM pg_options_to_table(umoptions) "
15107 "ORDER BY option_name"
15109 "FROM pg_user_mappings "
15110 "WHERE srvid = '%u' "
15121 {
15153 }
15161 }
15163 /*
15164 * Write out default privileges information
15165 */
15166 static void
15168 {
15170 PQExpBuffer q;
15171 PQExpBuffer tag;
15174 /* Do nothing if not dumping schema, or if we're skipping ACLs */
15182 {
15199 /* shouldn't get here */
15203 }
15207 /* build the actual command(s) for this tuple */
15215 q))
15231 }
15233 /*----------
15234 * Write out grant/revoke information
15235 *
15236 * 'objDumpId' is the dump ID of the underlying object.
15237 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
15238 * or InvalidDumpId if there is no need for a second dependency.
15239 * 'type' must be one of
15240 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
15241 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
15242 * 'name' is the formatted name of the object. Must be quoted etc. already.
15243 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
15244 * (Currently we assume that subname is only provided for table columns.)
15245 * 'nspname' is the namespace the object is in (NULL if none).
15246 * 'tag' is the tag to use for the ACL TOC entry; typically, this is NULL
15247 * to use the default for the object type.
15248 * 'owner' is the owner, NULL if there is no owner (for languages).
15249 * 'dacl' is the DumpableAcl struct for the object.
15250 *
15251 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
15252 * no ACL entry was created.
15253 *----------
15254 */
15255 static DumpId
15260 {
15268 PQExpBuffer sql;
15270 /* Do nothing if ACL dump is not enabled */
15274 /* --data-only skips ACLs *except* large object ACLs */
15280 /*
15281 * In binary upgrade mode, we don't run an extension's script but instead
15282 * dump out the objects independently and then recreate them. To preserve
15283 * any initial privileges which were set on extension objects, we need to
15284 * compute the set of GRANT and REVOKE commands necessary to get from the
15285 * default privileges of an object to its initial privileges as recorded
15286 * in pg_init_privs.
15287 *
15288 * At restore time, we apply these commands after having called
15289 * binary_upgrade_set_record_init_privs(true). That tells the backend to
15290 * copy the results into pg_init_privs. This is how we preserve the
15291 * contents of that catalog across binary upgrades.
15292 */
15295 {
15302 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
15303 }
15305 /*
15306 * Now figure the GRANT and REVOKE commands needed to get to the object's
15307 * actual current ACL, starting from the initprivs if given, else from the
15308 * object-type-specific default. Also, while buildACLCommands will assume
15309 * that a NULL/empty acls string means it needn't do anything, what that
15310 * actually represents is the object-type-specific default; so we need to
15311 * substitute the acldefault string to get the right results in that case.
15312 */
15314 {
15318 }
15319 else
15329 {
15338 else
15358 }
15363 }
15365 /*
15366 * dumpSecLabel
15367 *
15368 * This routine is used to dump any security labels associated with the
15369 * object handed to this routine. The routine takes the object type
15370 * and object name (ready to print, except for schema decoration), plus
15371 * the namespace and owner of the object (for labeling the ArchiveEntry),
15372 * plus catalog ID and subid which are the lookup key for pg_seclabel,
15373 * plus the dump ID for the object (for setting a dependency).
15374 * If a matching pg_seclabel entry is found, it is dumped.
15375 *
15376 * Note: although this routine takes a dumpId for dependency purposes,
15377 * that purpose is just to mark the dependency in the emitted dump file
15378 * for possible future use by pg_restore. We do NOT use it for determining
15379 * ordering of the label in the dump file, because this routine is called
15380 * after dependency sorting occurs. This routine should be called just after
15381 * calling ArchiveEntry() for the specified object.
15382 */
15383 static void
15387 {
15392 PQExpBuffer query;
15394 /* do nothing, if --no-security-labels is supplied */
15398 /*
15399 * Security labels are schema not data ... except large object labels are
15400 * data
15401 */
15403 {
15406 }
15407 else
15408 {
15409 /* We do dump large object security labels in binary-upgrade mode */
15412 }
15414 /* Search for security labels associated with catalogId, using table */
15420 {
15421 /*
15422 * Ignore label entries for which the subid doesn't match.
15423 */
15435 }
15438 {
15452 }
15455 }
15457 /*
15458 * dumpTableSecLabel
15459 *
15460 * As above, but dump security label for both the specified table (or view)
15461 * and its columns.
15462 */
15463 static void
15465 {
15470 PQExpBuffer query;
15471 PQExpBuffer target;
15473 /* do nothing, if --no-security-labels is supplied */
15477 /* SecLabel are SCHEMA not data */
15481 /* Search for comments associated with relation, using table */
15486 /* If security labels exist, build SECURITY LABEL statements */
15494 {
15502 {
15505 }
15506 else
15507 {
15509 /* first fmtXXX result must be consumed before calling again */
15513 }
15518 }
15520 {
15533 }
15536 }
15538 /*
15539 * findSecLabels
15540 *
15541 * Find the security label(s), if any, associated with the given object.
15542 * All the objsubid values associated with the given classoid/objoid are
15543 * found with one search.
15544 */
15545 static int
15547 {
15554 {
15557 }
15559 /*
15560 * Do binary search to find some item matching the object.
15561 */
15565 {
15576 else
15578 }
15581 {
15584 }
15586 /*
15587 * Now determine how many items match the object. The search loop
15588 * invariant still holds: only items between low and high inclusive could
15589 * match.
15590 */
15593 {
15597 middle--;
15598 nmatch++;
15599 }
15605 {
15609 middle++;
15610 nmatch++;
15611 }
15614 }
15616 /*
15617 * collectSecLabels
15618 *
15619 * Construct a table of all security labels available for database objects;
15620 * also set the has-seclabel component flag for each relevant object.
15621 *
15622 * The table is sorted by classoid/objid/objsubid for speed in lookup.
15623 */
15624 static void
15626 {
15628 PQExpBuffer query;
15641 "SELECT label, provider, classoid, objoid, objsubid "
15642 "FROM pg_catalog.pg_seclabel "
15647 /* Construct lookup table containing OIDs in numeric form */
15661 {
15662 CatalogId objId;
15669 /* We needn't remember labels that don't match any dumpable object */
15677 /*
15678 * Labels on columns of composite types are linked to the type's
15679 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
15680 * in the type's own DumpableObject.
15681 */
15684 {
15690 }
15691 else
15699 nseclabels++;
15700 }
15704 }
15706 /*
15707 * dumpTable
15708 * write out to fout the declarations (not data) of a user-defined table
15709 */
15710 static void
15712 {
15717 /* Do nothing if not dumping schema */
15722 {
15725 else
15727 }
15729 /* Handle the ACL here */
15732 {
15736 tableAclDumpId =
15741 }
15743 /*
15744 * Handle column ACLs, if any. Note: we pull these with a separate query
15745 * rather than trying to fetch them during getTableAttrs, so that we won't
15746 * miss ACLs on system columns. Doing it this way also allows us to dump
15747 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
15748 */
15750 {
15756 {
15757 /* Set up query for column ACLs */
15762 {
15763 /*
15764 * In principle we should call acldefault('c', relowner) to
15765 * get the default ACL for a column. However, we don't
15766 * currently store the numeric OID of the relowner in
15767 * TableInfo. We could convert the owner name using regrole,
15768 * but that creates a risk of failure due to concurrent role
15769 * renames. Given that the default ACL for columns is empty
15770 * and is likely to stay that way, it's not worth extra cycles
15771 * and risk to avoid hard-wiring that knowledge here.
15772 */
15774 "SELECT at.attname, "
15775 "at.attacl, "
15776 "'{}' AS acldefault, "
15777 "pip.privtype, pip.initprivs "
15778 "FROM pg_catalog.pg_attribute at "
15779 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
15780 "(at.attrelid = pip.objoid "
15781 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
15782 "AND at.attnum = pip.objsubid) "
15783 "WHERE at.attrelid = $1 AND "
15784 "NOT at.attisdropped "
15785 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
15787 }
15788 else
15789 {
15791 "SELECT attname, attacl, '{}' AS acldefault, "
15792 "NULL AS privtype, NULL AS initprivs "
15793 "FROM pg_catalog.pg_attribute "
15794 "WHERE attrelid = $1 AND NOT attisdropped "
15795 "AND attacl IS NOT NULL "
15797 }
15802 }
15811 {
15817 DumpableAcl coldacl;
15826 /*
15827 * Column's GRANT type is always TABLE. Each column ACL depends
15828 * on the table-level ACL, since we can restore column ACLs in
15829 * parallel but the table-level ACL has to be done first.
15830 */
15836 }
15839 }
15842 }
15844 /*
15845 * Create the AS clause for a view or materialized view. The semicolon is
15846 * stripped because a materialized view must add a WITH NO DATA clause.
15847 *
15848 * This returns a new buffer which must be freed by the caller.
15849 */
15850 static PQExpBuffer
15852 {
15858 /* Fetch the view definition */
15866 {
15870 else
15873 }
15881 /* Strip off the trailing semicolon so that other things may follow. */
15889 }
15891 /*
15892 * Create a dummy AS clause for a view. This is used when the real view
15893 * definition has to be postponed because of circular dependencies.
15894 * We must duplicate the view's external properties -- column names and types
15895 * (including collation) -- so that it works for subsequent references.
15896 *
15897 * This returns a new buffer which must be freed by the caller.
15898 */
15899 static PQExpBuffer
15901 {
15908 {
15915 /*
15916 * Must add collation if not default for the type, because CREATE OR
15917 * REPLACE VIEW won't change it
15918 */
15920 {
15927 }
15930 }
15933 }
15935 /*
15936 * dumpTableSchema
15937 * write the declaration (not data) of one user-defined table or view
15938 */
15939 static void
15941 {
15954 k;
15956 /* We had better have loaded per-column details about this table */
15964 qrelname);
15969 /* Is it a table or a view? */
15971 {
15972 PQExpBuffer result;
15974 /*
15975 * Note: keep this code in sync with the is_view case in dumpRule()
15976 */
15990 else
15991 {
15993 {
15997 }
15999 }
16006 }
16007 else
16008 {
16014 /*
16015 * Set reltypename, and collect any relkind-specific data that we
16016 * didn't fetch during getTables().
16017 */
16019 {
16021 {
16027 /* retrieve partition key definition */
16036 }
16038 {
16046 /* retrieve name of foreign server and generic options */
16048 "SELECT fs.srvname, "
16049 "pg_catalog.array_to_string(ARRAY("
16050 "SELECT pg_catalog.quote_ident(option_name) || "
16051 "' ' || pg_catalog.quote_literal(option_value) "
16052 "FROM pg_catalog.pg_options_to_table(ftoptions) "
16053 "ORDER BY option_name"
16055 "FROM pg_catalog.pg_foreign_table ft "
16056 "JOIN pg_catalog.pg_foreign_server fs "
16057 "ON (fs.oid = ft.ftserver) "
16070 }
16077 }
16088 /*
16089 * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
16090 * ignore it when dumping if it was set in this case.
16091 */
16096 reltypename,
16097 qualrelname);
16099 /*
16100 * Attach to type, if reloftype; except in case of a binary upgrade,
16101 * we dump the table normally and attach it to the type afterward.
16102 */
16106 zeroIsError));
16109 {
16110 /* Dump the attributes */
16113 {
16114 /*
16115 * Normally, dump if it's locally defined in this table, and
16116 * not dropped. But for binary upgrade, we'll dump all the
16117 * columns, and then fix up the dropped and nonlocal cases
16118 * below.
16119 */
16121 {
16125 /*
16126 * Default value --- suppress if to be printed separately
16127 * or not at all.
16128 */
16133 /*
16134 * Not Null constraint --- print it if it is locally
16135 * defined, or if binary upgrade. (In the latter case, we
16136 * reset conislocal below.)
16137 */
16143 /*
16144 * Skip column if fully defined by reloftype, except in
16145 * binary upgrade
16146 */
16152 /* Format properly if not first attr */
16155 else
16158 actual_atts++;
16160 /* Attribute name */
16164 {
16165 /*
16166 * ALTER TABLE DROP COLUMN clears
16167 * pg_attribute.atttypid, so we will not have gotten a
16168 * valid type name; insert INTEGER as a stopgap. We'll
16169 * clean things up later.
16170 */
16172 /* and skip to the next column */
16174 }
16176 /*
16177 * Attribute type; print it except when creating a typed
16178 * table ('OF type_name'), but in binary-upgrade mode,
16179 * print it in that case too.
16180 */
16182 {
16185 }
16188 {
16192 else
16195 }
16203 {
16206 else
16212 }
16214 /* Add collation if not default for the type */
16216 {
16223 }
16224 }
16226 /*
16227 * On the other hand, if we choose not to print a column
16228 * (likely because it is created by inheritance), but the
16229 * column has a locally-defined not-null constraint, we need
16230 * to dump the constraint as a standalone object.
16231 *
16232 * This syntax isn't SQL-conforming, but if you wanted
16233 * standard output you wouldn't be creating non-standard
16234 * objects to begin with.
16235 */
16240 {
16241 /* Format properly if not first attr */
16244 else
16247 actual_atts++;
16252 else
16256 }
16257 }
16259 /*
16260 * Add non-inherited CHECK constraints, if any.
16261 *
16262 * For partitions, we need to include check constraints even if
16263 * they're not defined locally, because the ALTER TABLE ATTACH
16264 * PARTITION that we'll emit later expects the constraint to be
16265 * there. (No need to fix conislocal: ATTACH PARTITION does that)
16266 */
16268 {
16277 else
16284 actual_atts++;
16285 }
16290 {
16291 /*
16292 * No attributes? we must have a parenthesized attribute list,
16293 * even though empty, when not using the OF TYPE syntax.
16294 */
16296 }
16298 /*
16299 * Emit the INHERITS clause (not for partitions), except in
16300 * binary-upgrade mode.
16301 */
16304 {
16307 {
16313 }
16315 }
16322 }
16326 {
16331 {
16334 }
16336 {
16340 fout);
16341 }
16343 }
16345 /* Dump generic options if any */
16349 /*
16350 * For materialized views, create the AS clause just like a view. At
16351 * this point, we always mark the view as not populated.
16352 */
16354 {
16355 PQExpBuffer result;
16361 }
16362 else
16365 /* Materialized views can depend on extensions */
16370 qualrelname);
16372 /*
16373 * in binary upgrade mode, update the catalog with any missing values
16374 * that might be present.
16375 */
16377 {
16379 {
16381 {
16391 }
16392 }
16393 }
16395 /*
16396 * To create binary-compatible heap files, we have to ensure the same
16397 * physical column order, including dropped columns, as in the
16398 * original. Therefore, we create dropped columns above and drop them
16399 * here, also updating their attlen/attalign values so that the
16400 * dropped column can be skipped properly. (We do not bother with
16401 * restoring the original attbyval setting.) Also, inheritance
16402 * relationships are set up by doing ALTER TABLE INHERIT rather than
16403 * using an INHERITS clause --- the latter would possibly mess up the
16404 * column order. That also means we have to take care about setting
16405 * attislocal correctly, plus fix up any inherited CHECK constraints.
16406 * Analogously, we set up typed tables using ALTER TABLE / OF here.
16407 *
16408 * We process foreign and partitioned tables here, even though they
16409 * lack heap storage, because they can participate in inheritance
16410 * relationships and we want this stuff to be consistent across the
16411 * inheritance tree. We can exclude indexes, toast tables, sequences
16412 * and matviews, even though they have storage, because we don't
16413 * support altering or dropping columns in them, nor can they be part
16414 * of inheritance trees.
16415 */
16420 {
16424 /*
16425 * Drop any dropped columns. Merge the pg_attribute manipulations
16426 * into a single SQL command, so that we don't cause repeated
16427 * relcache flushes on the target table. Otherwise we risk O(N^2)
16428 * relcache bloat while dropping N columns.
16429 */
16433 {
16435 {
16437 {
16440 "SET attlen = v.dlen, "
16441 "attalign = v.dalign, "
16445 }
16446 else
16453 /* The ALTER ... DROP COLUMN commands must come after */
16458 }
16459 }
16461 {
16467 /* Now we can issue the actual DROP COLUMN commands */
16469 }
16471 /*
16472 * Fix up inherited columns. As above, do the pg_attribute
16473 * manipulations in a single SQL command.
16474 */
16477 {
16480 {
16482 {
16491 }
16492 else
16495 }
16496 }
16500 /*
16501 * Fix up not-null constraints that come from inheritance. As
16502 * above, do the pg_constraint manipulations in a single SQL
16503 * command. (Actually, two in special cases, if we're doing an
16504 * upgrade from < 18).
16505 */
16510 {
16511 /*
16512 * If a not-null constraint comes from inheritance, reset
16513 * conislocal. The inhcount is fixed by ALTER TABLE INHERIT,
16514 * below. Special hack: in versions < 18, columns with no
16515 * local definition need their constraint to be matched by
16516 * column number in conkeys instead of by constraint name,
16517 * because the latter is not available. (We distinguish the
16518 * case because the constraint name is the empty string.)
16519 */
16522 {
16524 {
16526 {
16534 }
16535 else
16538 }
16539 else
16540 {
16542 {
16550 }
16551 else
16554 }
16555 }
16556 }
16565 /*
16566 * Add inherited CHECK constraints, if any.
16567 *
16568 * For partitions, they were already dumped, and conislocal
16569 * doesn't need fixing.
16570 *
16571 * As above, issue only one direct manipulation of pg_constraint.
16572 * Although it is tempting to merge the ALTER ADD CONSTRAINT
16573 * commands into one as well, refrain for now due to concern about
16574 * possible backend memory bloat if there are many such
16575 * constraints.
16576 */
16580 {
16592 /* Update pg_constraint after all the ALTER TABLEs */
16594 {
16602 }
16603 else
16606 }
16608 {
16611 }
16614 {
16617 {
16621 qualrelname,
16623 }
16624 }
16627 {
16630 qualrelname,
16632 zeroIsError));
16633 }
16634 }
16636 /*
16637 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
16638 * relminmxid of all vacuumable relations. (While vacuum.c processes
16639 * TOAST tables semi-independently, here we see them only as children
16640 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
16641 * child toast table is handled below.)
16642 */
16646 {
16656 {
16657 /*
16658 * The toast table will have the same OID at restore, so we
16659 * can safely target it by OID.
16660 */
16661 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
16667 }
16668 }
16670 /*
16671 * In binary_upgrade mode, restore matviews' populated status by
16672 * poking pg_class directly. This is pretty ugly, but we can't use
16673 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
16674 * matview is not populated even though this matview is; in any case,
16675 * we want to transfer the matview's heap storage, not run REFRESH.
16676 */
16679 {
16686 }
16688 /*
16689 * Dump additional per-column properties that we can't handle in the
16690 * main CREATE TABLE command.
16691 */
16693 {
16694 /* None of this applies to dropped columns */
16698 /*
16699 * Dump per-column statistics information. We only issue an ALTER
16700 * TABLE statement if the attstattarget entry for this column is
16701 * not the default value.
16702 */
16709 /*
16710 * Dump per-column storage information. The statement is only
16711 * dumped if the storage has been changed from the type's default.
16712 */
16714 {
16716 {
16731 }
16733 /*
16734 * Only dump the statement if it's a storage type we recognize
16735 */
16740 storage);
16741 }
16743 /*
16744 * Dump per-column compression, if it's been set.
16745 */
16747 {
16751 {
16761 }
16767 cmname);
16768 }
16770 /*
16771 * Dump per-column attributes.
16772 */
16779 /*
16780 * Dump per-column fdw options.
16781 */
16788 qualrelname,
16796 }
16798 /*
16799 * dump properties we only have ALTER TABLE syntax for
16800 */
16805 {
16807 {
16808 /* nothing to do, will be set when the index is dumped */
16809 }
16811 {
16813 qualrelname);
16814 }
16816 {
16818 qualrelname);
16819 }
16820 }
16824 qualrelname);
16832 {
16836 /*
16837 * _selectTablespace() relies on tablespace-enabled objects in the
16838 * default tablespace to have a tablespace of "" (empty string) versus
16839 * non-tablespace-enabled objects to have a tablespace of NULL.
16840 * getTables() sets tbinfo->reltablespace to "" for the default
16841 * tablespace (not NULL).
16842 */
16862 }
16864 /* Dump Table Comments */
16868 /* Dump Table Security Labels */
16872 /* Dump comments on inlined table constraints */
16874 {
16882 }
16889 }
16891 /*
16892 * dumpTableAttach
16893 * write to fout the commands to attach a child partition
16894 *
16895 * Child partitions are always made by creating them separately
16896 * and then using ATTACH PARTITION, rather than using
16897 * CREATE TABLE ... PARTITION OF. This is important for preserving
16898 * any possible discrepancy in column layout, to allow assigning the
16899 * correct tablespace if different, and so that it's possible to restore
16900 * a partition without restoring its parent. (You'll get an error from
16901 * the ATTACH PARTITION command, but that can be ignored, or skipped
16902 * using "pg_restore -L" if you prefer.) The last point motivates
16903 * treating ATTACH PARTITION as a completely separate ArchiveEntry
16904 * rather than emitting it within the child partition's ArchiveEntry.
16905 */
16906 static void
16908 {
16910 PQExpBuffer q;
16914 /* Do nothing if not dumping schema */
16921 {
16922 /* Set up query for partbound details */
16927 "SELECT pg_get_expr(c.relpartbound, c.oid) "
16928 "FROM pg_class c "
16934 }
16943 /* Perform ALTER TABLE on the parent */
16950 partbound);
16952 /*
16953 * There is no point in creating a drop query as the drop is done by table
16954 * drop. (If you think to change this, see also _printTocEntry().)
16955 * Although this object doesn't really have ownership as such, set the
16956 * owner field anyway to ensure that the command is run by the correct
16957 * role at restore time.
16958 */
16969 }
16971 /*
16972 * dumpAttrDef --- dump an attribute's default-value declaration
16973 */
16974 static void
16976 {
16980 PQExpBuffer q;
16981 PQExpBuffer delq;
16986 /* Do nothing if not dumping schema */
16990 /* Skip if not "separate"; it was dumped in the table's definition */
17026 }
17028 /*
17029 * getAttrName: extract the correct name for an attribute
17030 *
17031 * The array tblInfo->attnames[] only provides names of user attributes;
17032 * if a system attribute number is supplied, we have to fake it.
17033 * We also do a little bit of bounds checking for safety's sake.
17034 */
17037 {
17041 {
17054 }
17058 }
17060 /*
17061 * dumpIndex
17062 * write out to fout a user-defined index
17063 */
17064 static void
17066 {
17070 PQExpBuffer q;
17071 PQExpBuffer delq;
17075 /* Do nothing if not dumping schema */
17085 /*
17086 * If there's an associated constraint, don't dump the index per se, but
17087 * do dump any comment for it. (This is safe because dependency ordering
17088 * will have ensured the constraint is emitted first.) Note that the
17089 * emitted comment has to be shown as depending on the constraint, not the
17090 * index, in such cases.
17091 */
17093 {
17105 /* Plain secondary index */
17108 /*
17109 * Append ALTER TABLE commands as needed to set properties that we
17110 * only have ALTER TABLE syntax for. Keep this in sync with the
17111 * similar code in dumpConstraint!
17112 */
17114 /* If the index is clustered, we need to record that. */
17116 {
17119 /* index name is not qualified in this syntax */
17121 qindxname);
17122 }
17124 /*
17125 * If the index has any statistics on some of its columns, generate
17126 * the associated ALTER INDEX queries.
17127 */
17129 {
17140 {
17143 /*
17144 * Note that this is a column number, so no quotes should be
17145 * used.
17146 */
17151 }
17152 }
17154 /* Indexes can depend on extensions */
17159 /* If the index defines identity, we need to record that. */
17161 {
17164 /* index name is not qualified in this syntax */
17166 qindxname);
17167 }
17184 }
17186 /* Dump Index Comments */
17199 }
17201 /*
17202 * dumpIndexAttach
17203 * write out to fout a partitioned-index attachment clause
17204 */
17205 static void
17207 {
17208 /* Do nothing if not dumping schema */
17213 {
17221 /*
17222 * There is no point in creating a drop query as the drop is done by
17223 * index drop. (If you think to change this, see also
17224 * _printTocEntry().) Although this object doesn't really have
17225 * ownership as such, set the owner field anyway to ensure that the
17226 * command is run by the correct role at restore time.
17227 */
17237 }
17238 }
17240 /*
17241 * dumpStatisticsExt
17242 * write out to fout an extended statistics object
17243 */
17244 static void
17246 {
17248 PQExpBuffer q;
17249 PQExpBuffer delq;
17250 PQExpBuffer query;
17255 /* Do nothing if not dumping schema */
17273 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
17276 /*
17277 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
17278 * for this statistics object is not the default value.
17279 */
17281 {
17286 }
17302 /* Dump Statistics Comments */
17315 }
17317 /*
17318 * dumpConstraint
17319 * write out to fout a user-defined constraint
17320 */
17321 static void
17323 {
17326 PQExpBuffer q;
17327 PQExpBuffer delq;
17331 /* Do nothing if not dumping schema */
17344 {
17345 /* Index-related constraint */
17365 {
17366 /* pg_get_constraintdef should have provided everything */
17368 }
17369 else
17370 {
17374 /*
17375 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
17376 * indexes. Being able to create this was fixed, but we need to
17377 * make the index distinct in order to be able to restore the
17378 * dump.
17379 */
17384 {
17395 }
17403 {
17414 }
17419 {
17423 }
17426 {
17430 }
17433 }
17435 /*
17436 * Append ALTER TABLE commands as needed to set properties that we
17437 * only have ALTER TABLE syntax for. Keep this in sync with the
17438 * similar code in dumpIndex!
17439 */
17441 /* If the index is clustered, we need to record that. */
17443 {
17446 /* index name is not qualified in this syntax */
17449 }
17451 /* If the index defines identity, we need to record that. */
17453 {
17456 /* index name is not qualified in this syntax */
17459 }
17461 /* Indexes can depend on extensions */
17483 }
17485 {
17488 /*
17489 * Foreign keys on partitioned tables are always declared as
17490 * inheriting to partitions; for all other cases, emit them as
17491 * applying ONLY directly to the named table, because that's how they
17492 * work for regular inherited tables.
17493 */
17496 /*
17497 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
17498 * current table data is not processed
17499 */
17522 }
17524 {
17525 /* CHECK constraint on a table */
17527 /* Ignore if not to be dumped separately, or if it was inherited */
17529 {
17530 /* not ONLY since we want it to propagate to children */
17553 }
17554 }
17556 {
17557 /* CHECK constraint on a domain */
17560 /* Ignore if not to be dumped separately */
17562 {
17585 }
17586 }
17587 else
17588 {
17591 }
17593 /* Dump Constraint Comments --- only works for table constraints */
17601 }
17603 /*
17604 * dumpTableConstraintComment --- dump a constraint's comment if any
17605 *
17606 * This is split out because we need the function in two different places
17607 * depending on whether the constraint is dumped as part of CREATE TABLE
17608 * or as a separate ALTER command.
17609 */
17610 static void
17612 {
17631 }
17635 {
17637 {
17640 }
17644 }
17646 /*
17647 * bsearch() comparator for SequenceItem
17648 */
17649 static int
17651 {
17656 }
17658 /*
17659 * collectSequences
17660 *
17661 * Construct a table of sequence information. This table is sorted by OID for
17662 * speed in lookup.
17663 */
17664 static void
17666 {
17670 /*
17671 * Before Postgres 10, sequence metadata is in the sequence itself. With
17672 * some extra effort, we might be able to use the sorted table for those
17673 * versions, but for now it seems unlikely to be worth it.
17674 *
17675 * Since version 18, we can gather the sequence data in this query with
17676 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
17677 */
17683 "seqstart, seqincrement, "
17684 "seqmax, seqmin, "
17685 "seqcache, seqcycle, "
17686 "NULL, 'f' "
17687 "FROM pg_catalog.pg_sequence "
17689 else
17691 "seqstart, seqincrement, "
17692 "seqmax, seqmin, "
17693 "seqcache, seqcycle, "
17694 "last_value, is_called "
17695 "FROM pg_catalog.pg_sequence, "
17696 "pg_get_sequence_data(seqrelid) "
17705 {
17716 }
17719 }
17721 /*
17722 * dumpSequence
17723 * write the declaration (not data) of one user-defined sequence
17724 */
17725 static void
17727 {
17731 int64 default_minv,
17732 default_maxv;
17740 /*
17741 * For versions >= 10, the sequence information is gathered in a sorted
17742 * table before any calls to dumpSequence(). See collectSequences() for
17743 * more information.
17744 */
17746 {
17754 }
17755 else
17756 {
17759 /*
17760 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
17761 *
17762 * Note: it might seem that 'bigint' potentially needs to be
17763 * schema-qualified, but actually that's a keyword.
17764 */
17766 "SELECT 'bigint' AS sequence_type, "
17767 "start_value, increment_by, max_value, min_value, "
17789 }
17791 /* Calculate default limits for a sequence of this type */
17794 {
17797 }
17799 {
17802 }
17804 {
17807 }
17808 else
17809 {
17812 }
17814 /*
17815 * Identity sequences are not to be dropped separately.
17816 */
17818 {
17821 }
17826 {
17830 /*
17831 * In older PG versions a sequence will have a pg_type entry, but v14
17832 * and up don't use that, so don't attempt to preserve the type OID.
17833 */
17834 }
17837 {
17853 /*
17854 * Emit persistence option only if it's different from the owning
17855 * table's. This avoids using this new syntax unnecessarily.
17856 */
17861 }
17862 else
17863 {
17872 }
17880 else
17885 else
17894 else
17897 /* binary_upgrade: no need to clear TOAST table oid */
17914 /*
17915 * If the sequence is owned by a table column, emit the ALTER for it as a
17916 * separate TOC entry immediately following the sequence's own entry. It's
17917 * OK to do this rather than using full sorting logic, because the
17918 * dependency that tells us it's owned will have forced the table to be
17919 * created first. We can't just include the ALTER in the TOC entry
17920 * because it will fail if we haven't reassigned the sequence owner to
17921 * match the table's owner.
17922 *
17923 * We need not schema-qualify the table reference because both sequence
17924 * and table must be in the same schema.
17925 */
17927 {
17935 {
17954 }
17955 }
17957 /* Dump Sequence Comments and Security Labels */
17973 }
17975 /*
17976 * dumpSequenceData
17977 * write the data of one user-defined sequence
17978 */
17979 static void
17981 {
17983 int64 last;
17987 /*
17988 * For versions >= 18, the sequence information is gathered in the sorted
17989 * array before any calls to dumpSequenceData(). See collectSequences()
17990 * for more information.
17991 *
17992 * For older versions, we have to query the sequence relations
17993 * individually.
17994 */
17996 {
18015 }
18016 else
18017 {
18030 }
18050 }
18052 /*
18053 * dumpTrigger
18054 * write the declaration of one user-defined table trigger
18055 */
18056 static void
18058 {
18061 PQExpBuffer query;
18062 PQExpBuffer delqry;
18063 PQExpBuffer trigprefix;
18064 PQExpBuffer trigidentity;
18068 /* Do nothing if not dumping schema */
18085 /* Triggers can depend on extensions */
18091 {
18094 /*
18095 * Partition triggers only appear here because their 'tgenabled' flag
18096 * differs from its parent's. The trigger is created already, so
18097 * remove the CREATE and replace it with an ALTER. (Clear out the
18098 * DROP query too, so that pg_dump --create does not cause errors.)
18099 */
18106 {
18121 }
18124 }
18126 {
18131 {
18145 }
18148 }
18176 }
18178 /*
18179 * dumpEventTrigger
18180 * write the declaration of one user-defined event trigger
18181 */
18182 static void
18184 {
18186 PQExpBuffer query;
18187 PQExpBuffer delqry;
18190 /* Do nothing if not dumping schema */
18205 {
18209 }
18216 {
18218 qevtname);
18220 {
18233 }
18235 }
18238 qevtname);
18261 }
18263 /*
18264 * dumpRule
18265 * Dump a rule
18266 */
18267 static void
18269 {
18273 PQExpBuffer query;
18274 PQExpBuffer cmd;
18275 PQExpBuffer delcmd;
18276 PQExpBuffer ruleprefix;
18281 /* Do nothing if not dumping schema */
18285 /*
18286 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
18287 * we do not want to dump it as a separate object.
18288 */
18292 /*
18293 * If it's an ON SELECT rule, we want to print it as a view definition,
18294 * instead of a rule.
18295 */
18306 {
18307 PQExpBuffer result;
18309 /*
18310 * We need OR REPLACE here because we'll be replacing a dummy view.
18311 * Otherwise this should look largely like the regular view dump code.
18312 */
18316 {
18320 }
18328 }
18329 else
18330 {
18331 /* In the rule case, just print pg_get_ruledef's result verbatim */
18345 }
18347 /*
18348 * Add the command to alter the rules replication firing semantics if it
18349 * differs from the default.
18350 */
18352 {
18355 {
18368 }
18369 }
18372 {
18373 /*
18374 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
18375 * REPLACE VIEW to replace the rule with something with minimal
18376 * dependencies.
18377 */
18378 PQExpBuffer result;
18385 }
18386 else
18387 {
18392 }
18409 /* Dump rule comments */
18422 }
18424 /*
18425 * getExtensionMembership --- obtain extension membership data
18426 *
18427 * We need to identify objects that are extension members as soon as they're
18428 * loaded, so that we can correctly determine whether they need to be dumped.
18429 * Generally speaking, extension member objects will get marked as *not* to
18430 * be dumped, as they will be recreated by the single CREATE EXTENSION
18431 * command. However, in binary upgrade mode we still need to dump the members
18432 * individually.
18433 */
18434 void
18437 {
18438 PQExpBuffer query;
18441 i;
18443 i_objid,
18444 i_refobjid;
18447 /* Nothing to do if no extensions */
18453 /* refclassid constraint is redundant but may speed the search */
18455 "classid, objid, refobjid "
18456 "FROM pg_depend "
18457 "WHERE refclassid = 'pg_extension'::regclass "
18458 "AND deptype = 'e' "
18469 /*
18470 * Since we ordered the SELECT by referenced ID, we can expect that
18471 * multiple entries for the same extension will appear together; this
18472 * saves on searches.
18473 */
18477 {
18478 CatalogId objId;
18479 Oid extId;
18490 {
18491 /* shouldn't happen */
18494 }
18497 }
18502 }
18504 /*
18505 * processExtensionTables --- deal with extension configuration tables
18506 *
18507 * There are two parts to this process:
18508 *
18509 * 1. Identify and create dump records for extension configuration tables.
18510 *
18511 * Extensions can mark tables as "configuration", which means that the user
18512 * is able and expected to modify those tables after the extension has been
18513 * loaded. For these tables, we dump out only the data- the structure is
18514 * expected to be handled at CREATE EXTENSION time, including any indexes or
18515 * foreign keys, which brings us to-
18516 *
18517 * 2. Record FK dependencies between configuration tables.
18518 *
18519 * Due to the FKs being created at CREATE EXTENSION time and therefore before
18520 * the data is loaded, we have to work out what the best order for reloading
18521 * the data is, to avoid FK violations when the tables are restored. This is
18522 * not perfect- we can't handle circular dependencies and if any exist they
18523 * will cause an invalid dump to be produced (though at least all of the data
18524 * is included for a user to manually restore). This is currently documented
18525 * but perhaps we can provide a better solution in the future.
18526 */
18527 void
18530 {
18532 PQExpBuffer query;
18535 i;
18537 i_confrelid;
18539 /* Nothing to do if no extensions */
18543 /*
18544 * Identify extension configuration tables and create TableDataInfo
18545 * objects for them, ensuring their data will be dumped even though the
18546 * tables themselves won't be.
18547 *
18548 * Note that we create TableDataInfo objects even in schema-only mode, ie,
18549 * user data in a configuration table is treated like schema data. This
18550 * seems appropriate since system data in a config table would get
18551 * reloaded by CREATE EXTENSION. If the extension is not listed in the
18552 * list of extensions to be included, none of its data is dumped.
18553 */
18555 {
18564 /*
18565 * Check if this extension is listed as to include in the dump. If
18566 * not, any table data associated with it is discarded.
18567 */
18573 /*
18574 * Check if this extension is listed as to exclude in the dump. If
18575 * yes, any table data associated with it is discarded.
18576 */
18583 {
18594 {
18604 /*
18605 * Tables of not-to-be-dumped extensions shouldn't be dumped
18606 * unless the table or its schema is explicitly included
18607 */
18609 {
18610 /* check table explicitly requested */
18613 configtbloid))
18616 /* check table's schema explicitly requested */
18618 DUMP_COMPONENT_DATA)
18620 }
18622 /* check table excluded by an exclusion switch */
18625 configtbloid))
18628 /* check schema excluded by an exclusion switch */
18634 {
18637 {
18640 }
18641 }
18642 }
18643 }
18648 }
18650 /*
18651 * Now that all the TableDataInfo objects have been created for all the
18652 * extensions, check their FK dependencies and register them to try and
18653 * dump the data out in an order that they can be restored in.
18654 *
18655 * Note that this is not a problem for user tables as their FKs are
18656 * recreated after the data has been loaded.
18657 */
18662 "SELECT conrelid, confrelid "
18663 "FROM pg_constraint "
18664 "JOIN pg_depend ON (objid = confrelid) "
18665 "WHERE contype = 'f' "
18666 "AND refclassid = 'pg_extension'::regclass "
18675 /* Now get the dependencies and register them */
18677 {
18678 Oid conrelid,
18679 confrelid;
18694 /*
18695 * Make referencing TABLE_DATA object depend on the referenced table's
18696 * TABLE_DATA object.
18697 */
18700 }
18703 }
18705 /*
18706 * getDependencies --- obtain available dependency data
18707 */
18708 static void
18710 {
18711 PQExpBuffer query;
18714 i;
18716 i_objid,
18717 i_refclassid,
18718 i_refobjid,
18719 i_deptype;
18727 /*
18728 * Messy query to collect the dependency data we need. Note that we
18729 * ignore the sub-object column, so that dependencies of or on a column
18730 * look the same as dependencies of or on a whole table.
18731 *
18732 * PIN dependencies aren't interesting, and EXTENSION dependencies were
18733 * already processed by getExtensionMembership.
18734 */
18736 "classid, objid, refclassid, refobjid, deptype "
18737 "FROM pg_depend "
18740 /*
18741 * Since we don't treat pg_amop entries as separate DumpableObjects, we
18742 * have to translate their dependencies into dependencies of their parent
18743 * opfamily. Ignore internal dependencies though, as those will point to
18744 * their parent opclass, which we needn't consider here (and if we did,
18745 * it'd just result in circular dependencies). Also, "loose" opfamily
18746 * entries will have dependencies on their parent opfamily, which we
18747 * should drop since they'd likewise become useless self-dependencies.
18748 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
18749 */
18751 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
18752 "FROM pg_depend d, pg_amop o "
18753 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18754 "classid = 'pg_amop'::regclass AND objid = o.oid "
18757 /* Likewise for pg_amproc entries */
18759 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
18760 "FROM pg_depend d, pg_amproc p "
18761 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18762 "classid = 'pg_amproc'::regclass AND objid = p.oid "
18765 /* Sort the output for efficiency below */
18778 /*
18779 * Since we ordered the SELECT by referencing ID, we can expect that
18780 * multiple entries for the same object will appear together; this saves
18781 * on searches.
18782 */
18786 {
18787 CatalogId objId;
18788 CatalogId refobjId;
18802 /*
18803 * Failure to find objects mentioned in pg_depend is not unexpected,
18804 * since for example we don't collect info about TOAST tables.
18805 */
18807 {
18808 #ifdef NOT_USED
18811 #endif
18813 }
18818 {
18819 #ifdef NOT_USED
18822 #endif
18824 }
18826 /*
18827 * For 'x' dependencies, mark the object for later; we still add the
18828 * normal dependency, for possible ordering purposes. Currently
18829 * pg_dump_sort.c knows to put extensions ahead of all object types
18830 * that could possibly depend on them, but this is safer.
18831 */
18835 /*
18836 * Ordinarily, table rowtypes have implicit dependencies on their
18837 * tables. However, for a composite type the implicit dependency goes
18838 * the other way in pg_depend; which is the right thing for DROP but
18839 * it doesn't produce the dependency ordering we need. So in that one
18840 * case, we reverse the direction of the dependency.
18841 */
18846 else
18847 /* normal case */
18849 }
18854 }
18857 /*
18858 * createBoundaryObjects - create dummy DumpableObjects to represent
18859 * dump section boundaries.
18860 */
18863 {
18879 }
18881 /*
18882 * addBoundaryDependencies - add dependencies as needed to enforce the dump
18883 * section boundaries.
18884 */
18885 static void
18888 {
18894 {
18897 /*
18898 * The classification of object types here must match the SECTION_xxx
18899 * values assigned during subsequent ArchiveEntry calls!
18900 */
18902 {
18928 /* Pre-data objects: must come before the pre-data boundary */
18935 /* Data objects: must come between the boundaries */
18952 /* Post-data objects: must come after the post-data boundary */
18956 /* Rules are post-data, but only if dumped separately */
18962 /* Constraints are post-data, but only if dumped separately */
18967 /* nothing to do */
18970 /* must come after the pre-data boundary */
18973 }
18974 }
18975 }
18978 /*
18979 * BuildArchiveDependencies - create dependency data for archive TOC entries
18980 *
18981 * The raw dependency data obtained by getDependencies() is not terribly
18982 * useful in an archive dump, because in many cases there are dependency
18983 * chains linking through objects that don't appear explicitly in the dump.
18984 * For example, a view will depend on its _RETURN rule while the _RETURN rule
18985 * will depend on other objects --- but the rule will not appear as a separate
18986 * object in the dump. We need to adjust the view's dependencies to include
18987 * whatever the rule depends on that is included in the dump.
18988 *
18989 * Just to make things more complicated, there are also "special" dependencies
18990 * such as the dependency of a TABLE DATA item on its TABLE, which we must
18991 * not rearrange because pg_restore knows that TABLE DATA only depends on
18992 * its table. In these cases we must leave the dependencies strictly as-is
18993 * even if they refer to not-to-be-dumped objects.
18994 *
18995 * To handle this, the convention is that "special" dependencies are created
18996 * during ArchiveEntry calls, and an archive TOC item that has any such
18997 * entries will not be touched here. Otherwise, we recursively search the
18998 * DumpableObject data structures to build the correct dependencies for each
18999 * archive TOC item.
19000 */
19001 static void
19003 {
19007 /* Scan all TOC entries in the archive */
19009 {
19015 /* No need to process entries that will not be dumped */
19018 /* Ignore entries that already have "special" dependencies */
19021 /* Otherwise, look up the item's original DumpableObject, if any */
19025 /* No work if it has no dependencies */
19028 /* Set up work array */
19032 /* Recursively find all dumpable dependencies */
19035 /* And save 'em ... */
19037 {
19042 }
19043 else
19045 }
19046 }
19048 /* Recursive search subroutine for BuildArchiveDependencies */
19049 static void
19052 {
19055 /*
19056 * Ignore section boundary objects: if we search through them, we'll
19057 * report lots of bogus dependencies.
19058 */
19064 {
19068 {
19069 /* Object will be dumped, so just reference it as a dependency */
19071 {
19075 }
19078 }
19079 else
19080 {
19081 /*
19082 * Object will not be dumped, so recursively consider its deps. We
19083 * rely on the assumption that sortDumpableObjects already broke
19084 * any dependency loops, else we might recurse infinitely.
19085 */
19091 }
19092 }
19093 }
19096 /*
19097 * getFormattedTypeName - retrieve a nicely-formatted type name for the
19098 * given type OID.
19099 *
19100 * This does not guarantee to schema-qualify the output, so it should not
19101 * be used to create the target object name for CREATE or ALTER commands.
19102 *
19103 * Note that the result is cached and must not be freed by the caller.
19104 */
19107 {
19110 PQExpBuffer query;
19114 {
19119 }
19121 /* see if we have the result cached in the type's TypeInfo record */
19128 oid);
19132 /* result of format_type is already quoted */
19138 /*
19139 * Cache the result for re-use in later requests, if possible. If we
19140 * don't have a TypeInfo for the type, the string will be leaked once the
19141 * caller is done with it ... but that case really should not happen, so
19142 * leaking if it does seems acceptable.
19143 */
19148 }
19150 /*
19151 * Return a column list clause for the given relation.
19152 *
19153 * Special case: if there are no undropped columns in the relation, return
19154 * "", not an invalid "()" column list.
19155 */
19158 {
19169 {
19178 }
19185 }
19187 /*
19188 * Check if a reloptions array is nonempty.
19189 */
19190 static bool
19192 {
19193 /* Don't want to print it if it's just "{}" */
19195 }
19197 /*
19198 * Format a reloptions array and append it to the given buffer.
19199 *
19200 * "prefix" is prepended to the option names; typically it's "" or "toast.".
19201 */
19202 static void
19205 {
19212 }
19214 /*
19215 * read_dump_filters - retrieve object identifier patterns from file
19216 *
19217 * Parse the specified filter file for include and exclude patterns, and add
19218 * them to the relevant lists. If the filename is "-" then filters will be
19219 * read from STDIN rather than a file.
19220 */
19221 static void
19223 {
19224 FilterStateData fstate;
19226 FilterCommandType comtype;
19227 FilterObjectType objtype;
19232 {
19234 {
19236 {
19267 objname);
19270 }
19271 }
19273 {
19275 {
19294 objname);
19298 objname);
19308 objname);
19310 }
19311 }
19312 else
19313 {
19316 }
19320 }
19323 }