| blob | e863913849240f3fff3d72acfdea570c43aba979 |
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-2023, 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 {
101 /* global decls */
106 /* The specified names/patterns should to match at least one entity */
111 /*
112 * Object inclusion/exclusion lists
113 *
114 * The string lists record the patterns given by command-line switches,
115 * which we then convert to lists of OIDs of matching objects.
116 */
140 /* override for standard extra_float_digits setting */
144 /* sorted table of role names */
148 /* sorted table of comments */
152 /* sorted table of security labels */
156 /*
157 * The default number of rows per INSERT when
158 * --inserts is specified without --rows-per-insert
159 */
160 #define DUMP_DEFAULT_ROWS_PER_INSERT 1
162 /*
163 * Macro for producing quoted, schema-qualified name of a dumpable object.
164 */
165 #define fmtQualifiedDumpable(obj) \
166 fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
167 (obj)->dobj.name)
306 PQExpBuffer upgrade_buffer,
307 Oid pg_type_oid,
311 PQExpBuffer upgrade_buffer,
314 PQExpBuffer upgrade_buffer,
332 int
334 {
354 ArchiveMode archiveMode;
398 /*
399 * the following options don't have an equivalent short option letter
400 */
438 };
444 /*
445 * Initialize what we need for parallel execution, especially for thread
446 * support on Windows.
447 */
453 {
455 {
458 }
460 {
463 }
464 }
470 {
472 {
520 PG_MAX_JOBS,
543 /* no-op, still accepted for backwards compatibility */
591 /* This covers the long options. */
627 /*
628 * dump_inserts also stores --rows-per-insert, careful not to
629 * overwrite that.
630 */
643 optarg);
648 optarg);
654 optarg);
659 optarg);
668 /* getopt_long already emitted a complaint */
671 }
672 }
674 /*
675 * Non-option argument specifies database name as long as it wasn't
676 * already specified with -d / --dbname
677 */
681 /* Complain if any arguments remain */
683 {
688 }
690 /* --column-inserts implies --inserts */
694 /*
695 * Binary upgrade mode implies dumping sequence data even in schema-only
696 * mode. This is not exposed as a separate option, but kept separate
697 * internally for clarity.
698 */
717 /*
718 * --inserts are already implied above if --column-inserts or
719 * --rows-per-insert were specified.
720 */
722 pg_fatal("option --on-conflict-do-nothing requires option --inserts, --rows-per-insert, or --column-inserts");
724 /* Identify archive format to emit */
727 /* archiveFormat specific setup */
731 /*
732 * Custom and directory formats are compressed by default with gzip when
733 * available, not the others. If gzip is not available, no compression is
734 * done by default.
735 */
738 {
739 #ifdef HAVE_LIBZ
741 #else
743 #endif
744 }
746 /*
747 * Compression options
748 */
752 compression_algorithm_str);
759 error_detail);
765 /*
766 * Disable support for zstd workers for now - these are based on
767 * threading, and it's unclear how it interacts with parallel dumps on
768 * platforms where that relies on threads too (e.g. Windows).
769 */
774 /*
775 * If emitting an archive format, we always want to emit a DATABASE item,
776 * in case --create is specified at pg_restore time.
777 */
781 /* Parallel backup only in the directory archive format so far */
785 /* Open the output file */
789 /* Make dump options accessible right away */
792 /* Register the cleanup hook */
795 /* Let the archiver know how noisy to be */
799 /*
800 * We allow the server to be back to 9.2, and up to any minor release of
801 * our own major version. (See also version check in pg_dumpall.c.)
802 */
808 /*
809 * Open the database using the Archiver, so it knows about it. Errors mean
810 * death.
811 */
815 /*
816 * On hot standbys, never try to dump unlogged table data, since it will
817 * just throw an error.
818 */
822 /*
823 * Find the last built-in OID, if needed (prior to 8.1)
824 *
825 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
826 */
831 /* Expand schema selection patterns into OID lists */
833 {
836 strict_names);
839 }
843 /* non-matching exclusion patterns aren't an error */
845 /* Expand table selection patterns into OID lists */
874 /* non-matching exclusion patterns aren't an error */
876 /* Expand extension selection patterns into OID lists */
878 {
881 strict_names);
884 }
886 /*
887 * Dumping LOs is the default for dumps where an inclusion switch is not
888 * used (an "include everything" dump). -B can be used to exclude LOs
889 * from those dumps. -b can be used to include LOs even when an inclusion
890 * switch is used.
891 *
892 * -s means "schema only" and LOs are data, not schema, so we never
893 * include LOs when -s is used.
894 */
898 /*
899 * Collect role names so we can map object owner OIDs to names.
900 */
903 /*
904 * Now scan the database and create DumpableObject structs for all the
905 * objects we intend to dump.
906 */
910 {
915 }
920 /*
921 * In binary-upgrade mode, we do not have to worry about the actual LO
922 * data or the associated metadata that resides in the pg_largeobject and
923 * pg_largeobject_metadata tables, respectively.
924 *
925 * However, we do need to collect LO information as there may be comments
926 * or other information on LOs that we do need to dump out.
927 */
931 /*
932 * Collect dependency data to assist in ordering the objects.
933 */
936 /*
937 * Collect ACLs, comments, and security labels, if wanted.
938 */
946 /* Lastly, create dummy objects to represent the section boundaries */
949 /* Get pointers to all the known DumpableObjects */
952 /*
953 * Add dummy dependencies to enforce the dump section ordering.
954 */
957 /*
958 * Sort the objects into a safe dump order (no forward references).
959 *
960 * We rely on dependency information to help us determine a safe order, so
961 * the initial sort is mostly for cosmetic purposes: we sort by name to
962 * ensure that logically identical schemas will dump identically.
963 */
969 /*
970 * Create archive TOC entries for all the objects to be dumped, in a safe
971 * order.
972 */
974 /*
975 * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
976 */
981 /* The database items are always next, unless we don't want them at all */
985 /* Now the rearrangeable objects. */
989 /*
990 * Set up options info to ensure we dump what we want.
991 */
995 /* if you change this list, see dumpOptionsFromRestoreOptions */
1033 /* Mark which entries should be output */
1036 /*
1037 * The archive's TOC entries are now marked as to which ones will actually
1038 * be output, so we can set up their dependency lists properly. This isn't
1039 * necessary for plain-text output, though.
1040 */
1044 /*
1045 * And finally we can do the actual output.
1046 *
1047 * Note: for non-plain-text output formats, the output file is written
1048 * inside CloseArchive(). This is, um, bizarre; but not worth changing
1049 * right now.
1050 */
1057 }
1060 static void
1062 {
1155 }
1157 static void
1160 {
1167 /*
1168 * Set the client encoding if requested.
1169 */
1171 {
1174 dumpencoding);
1175 }
1177 /*
1178 * Get the active encoding and the standard_conforming_strings setting, so
1179 * we know how to escape strings.
1180 */
1186 /*
1187 * Set the role if requested. In a parallel dump worker, we'll be passed
1188 * use_role == NULL, but AH->use_role is already set (if user specified it
1189 * originally) and we should use that.
1190 */
1194 /* Set the role if requested */
1196 {
1203 /* save it for possible later use by parallel workers */
1206 }
1208 /* Set the datestyle to ISO to ensure the dump's portability */
1211 /* Likewise, avoid using sql_standard intervalstyle */
1214 /*
1215 * Use an explicitly specified extra_float_digits if it has been provided.
1216 * Otherwise, set extra_float_digits so that we can dump float data
1217 * exactly (given correctly implemented float I/O code, anyway).
1218 */
1220 {
1224 extra_float_digits);
1227 }
1228 else
1231 /*
1232 * Disable synchronized scanning, to prevent unpredictable changes in row
1233 * ordering across a dump and reload.
1234 */
1237 /*
1238 * Disable timeouts if supported.
1239 */
1246 /*
1247 * Quote all identifiers, if requested.
1248 */
1252 /*
1253 * Adjust row-security mode, if supported.
1254 */
1256 {
1259 else
1261 }
1263 /*
1264 * Initialize prepared-query state to "nothing prepared". We do this here
1265 * so that a parallel dump worker will have its own state.
1266 */
1269 /*
1270 * Start transaction-snapshot mode transaction to dump consistent data.
1271 */
1274 /*
1275 * To support the combination of serializable_deferrable with the jobs
1276 * option we use REPEATABLE READ for the worker connections that are
1277 * passed a snapshot. As long as the snapshot is acquired in a
1278 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1279 * REPEATABLE READ transaction provides the appropriate integrity
1280 * guarantees. This is a kluge, but safe for back-patching.
1281 */
1284 "SET TRANSACTION ISOLATION LEVEL "
1286 else
1288 "SET TRANSACTION ISOLATION LEVEL "
1291 /*
1292 * If user specified a snapshot to use, select that. In a parallel dump
1293 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1294 * is already set (if the server can handle it) and we should use that.
1295 */
1300 {
1307 }
1309 {
1313 }
1314 }
1316 /* Set up connection for a parallel worker process */
1317 static void
1319 {
1320 /*
1321 * We want to re-select all the same values the leader connection is
1322 * using. We'll have inherited directly-usable values in
1323 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1324 * inherited encoding value back to a string to pass to setup_connection.
1325 */
1328 NULL,
1329 NULL);
1330 }
1334 {
1344 }
1346 static ArchiveFormat
1348 {
1349 ArchiveFormat archiveFormat;
1354 {
1355 /* This is used by pg_dumpall, and is not documented */
1358 }
1375 else
1378 }
1380 /*
1381 * Find the OIDs of all schemas matching the given list of patterns,
1382 * and append them to the given OID list.
1383 */
1384 static void
1389 {
1390 PQExpBuffer query;
1400 /*
1401 * The loop below runs multiple SELECTs might sometimes result in
1402 * duplicate entries in the OID list, but we don't care.
1403 */
1406 {
1407 PQExpBufferData dbbuf;
1428 {
1430 }
1434 }
1437 }
1439 /*
1440 * Find the OIDs of all extensions matching the given list of patterns,
1441 * and append them to the given OID list.
1442 */
1443 static void
1448 {
1449 PQExpBuffer query;
1459 /*
1460 * The loop below runs multiple SELECTs might sometimes result in
1461 * duplicate entries in the OID list, but we don't care.
1462 */
1464 {
1481 {
1483 }
1487 }
1490 }
1492 /*
1493 * Find the OIDs of all foreign servers matching the given list of patterns,
1494 * and append them to the given OID list.
1495 */
1496 static void
1500 {
1501 PQExpBuffer query;
1511 /*
1512 * The loop below runs multiple SELECTs might sometimes result in
1513 * duplicate entries in the OID list, but we don't care.
1514 */
1517 {
1538 }
1541 }
1543 /*
1544 * Find the OIDs of all tables matching the given list of patterns,
1545 * and append them to the given OID list. See also expand_dbname_patterns()
1546 * in pg_dumpall.c
1547 */
1548 static void
1552 {
1553 PQExpBuffer query;
1563 /*
1564 * this might sometimes result in duplicate entries in the OID list, but
1565 * we don't care.
1566 */
1569 {
1570 PQExpBufferData dbbuf;
1573 /*
1574 * Query must remain ABSOLUTELY devoid of unqualified names. This
1575 * would be unnecessary given a pg_table_is_visible() variant taking a
1576 * search_path argument.
1577 *
1578 * For with_child_tables, we start with the basic query's results and
1579 * recursively search the inheritance tree to add child tables.
1580 */
1582 {
1584 }
1587 "SELECT c.oid"
1595 RELKIND_PARTITIONED_TABLE);
1609 {
1617 }
1622 ALWAYS_SECURE_SEARCH_PATH_SQL));
1627 {
1629 }
1633 }
1636 }
1638 /*
1639 * Verifies that the connected database name matches the given database name,
1640 * and if not, dies with an error about the given pattern.
1641 *
1642 * The 'dbname' argument should be a literal name parsed from 'pattern'.
1643 */
1644 static void
1646 {
1655 pattern);
1656 }
1658 /*
1659 * checkExtensionMembership
1660 * Determine whether object is an extension member, and if so,
1661 * record an appropriate dependency and set the object's dump flag.
1662 *
1663 * It's important to call this for each object that could be an extension
1664 * member. Generally, we integrate this with determining the object's
1665 * to-be-dumped-ness, since extension membership overrides other rules for that.
1666 *
1667 * Returns true if object is an extension member, else false.
1668 */
1669 static bool
1671 {
1679 /* Record dependency so that getDependencies needn't deal with that */
1682 /*
1683 * In 9.6 and above, mark the member object to have any non-initial ACL,
1684 * policies, and security labels dumped.
1685 *
1686 * Note that any initial ACLs (see pg_init_privs) will be removed when we
1687 * extract the information about the object. We don't provide support for
1688 * initial policies and security labels and it seems unlikely for those to
1689 * ever exist, but we may have to revisit this later.
1690 *
1691 * Prior to 9.6, we do not include any extension member components.
1692 *
1693 * In binary upgrades, we still dump all components of the members
1694 * individually, since the idea is to exactly reproduce the database
1695 * contents rather than replace the extension contents with something
1696 * different.
1697 */
1700 else
1701 {
1704 else
1706 DUMP_COMPONENT_SECLABEL |
1707 DUMP_COMPONENT_POLICY);
1708 }
1711 }
1713 /*
1714 * selectDumpableNamespace: policy-setting subroutine
1715 * Mark a namespace as to be dumped or not
1716 */
1717 static void
1719 {
1720 /*
1721 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
1722 * and (for --clean) a DROP SCHEMA statement. (In the absence of
1723 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
1724 */
1727 /*
1728 * If specific tables are being dumped, do not dump any complete
1729 * namespaces. If specific namespaces are being dumped, dump just those
1730 * namespaces. Otherwise, dump all non-system namespaces.
1731 */
1741 {
1742 /*
1743 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
1744 * they are interesting (and not the original ACLs which were set at
1745 * initdb time, see pg_init_privs).
1746 */
1748 }
1751 {
1752 /* Other system schemas don't get dumped */
1754 }
1756 {
1757 /*
1758 * The public schema is a strange beast that sits in a sort of
1759 * no-mans-land between being a system object and a user object.
1760 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
1761 * a comment and an indication of ownership. If the owner is the
1762 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
1763 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
1764 */
1771 /*
1772 * Also, make like it has a comment even if it doesn't; this is so
1773 * that we'll emit a command to drop the comment, if appropriate.
1774 * (Without this, we'd not call dumpCommentExtended for it.)
1775 */
1777 }
1778 else
1781 /*
1782 * In any case, a namespace can be excluded by an exclusion switch
1783 */
1789 /*
1790 * If the schema belongs to an extension, allow extension membership to
1791 * override the dump decision for the schema itself. However, this does
1792 * not change dump_contains, so this won't change what we do with objects
1793 * within the schema. (If they belong to the extension, they'll get
1794 * suppressed by it, otherwise not.)
1795 */
1797 }
1799 /*
1800 * selectDumpableTable: policy-setting subroutine
1801 * Mark a table as to be dumped or not
1802 */
1803 static void
1805 {
1809 /*
1810 * If specific tables are being dumped, dump just those tables; else, dump
1811 * according to the parent namespace's dump flag.
1812 */
1817 else
1820 /*
1821 * In any case, a table can be excluded by an exclusion switch
1822 */
1827 }
1829 /*
1830 * selectDumpableType: policy-setting subroutine
1831 * Mark a type as to be dumped or not
1832 *
1833 * If it's a table's rowtype or an autogenerated array type, we also apply a
1834 * special type code to facilitate sorting into the desired order. (We don't
1835 * want to consider those to be ordinary types because that would bring tables
1836 * up into the datatype part of the dump order.) We still set the object's
1837 * dump flag; that's not going to cause the dummy type to be dumped, but we
1838 * need it so that casts involving such types will be dumped correctly -- see
1839 * dumpCast. This means the flag should be set the same as for the underlying
1840 * object (the table or base type).
1841 */
1842 static void
1844 {
1845 /* skip complex types, except for standalone composite types */
1848 {
1854 else
1857 }
1859 /* skip auto-generated array types */
1861 {
1864 /*
1865 * Fall through to set the dump flag; we assume that the subsequent
1866 * rules will do the same thing as they would for the array's base
1867 * type. (We cannot reliably look up the base type here, since
1868 * getTypes may not have processed it yet.)
1869 */
1870 }
1875 /* Dump based on if the contents of the namespace are being dumped */
1877 }
1879 /*
1880 * selectDumpableDefaultACL: policy-setting subroutine
1881 * Mark a default ACL as to be dumped or not
1882 *
1883 * For per-schema default ACLs, dump if the schema is to be dumped.
1884 * Otherwise dump if we are dumping "everything". Note that dataOnly
1885 * and aclsSkip are checked separately.
1886 */
1887 static void
1889 {
1890 /* Default ACLs can't be extension members */
1893 /* default ACLs are considered part of the namespace */
1895 else
1898 }
1900 /*
1901 * selectDumpableCast: policy-setting subroutine
1902 * Mark a cast as to be dumped or not
1903 *
1904 * Casts do not belong to any particular namespace (since they haven't got
1905 * names), nor do they have identifiable owners. To distinguish user-defined
1906 * casts from built-in ones, we must resort to checking whether the cast's
1907 * OID is in the range reserved for initdb.
1908 */
1909 static void
1911 {
1915 /*
1916 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
1917 * support ACLs currently.
1918 */
1921 else
1924 }
1926 /*
1927 * selectDumpableProcLang: policy-setting subroutine
1928 * Mark a procedural language as to be dumped or not
1929 *
1930 * Procedural languages do not belong to any particular namespace. To
1931 * identify built-in languages, we must resort to checking whether the
1932 * language's OID is in the range reserved for initdb.
1933 */
1934 static void
1936 {
1940 /*
1941 * Only include procedural languages when we are dumping everything.
1942 *
1943 * For from-initdb procedural languages, only include ACLs, as we do for
1944 * the pg_catalog namespace. We need this because procedural languages do
1945 * not live in any namespace.
1946 */
1949 else
1950 {
1954 else
1956 }
1957 }
1959 /*
1960 * selectDumpableAccessMethod: policy-setting subroutine
1961 * Mark an access method as to be dumped or not
1962 *
1963 * Access methods do not belong to any particular namespace. To identify
1964 * built-in access methods, we must resort to checking whether the
1965 * method's OID is in the range reserved for initdb.
1966 */
1967 static void
1969 {
1973 /*
1974 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
1975 * they do not support ACLs currently.
1976 */
1979 else
1982 }
1984 /*
1985 * selectDumpableExtension: policy-setting subroutine
1986 * Mark an extension as to be dumped or not
1987 *
1988 * Built-in extensions should be skipped except for checking ACLs, since we
1989 * assume those will already be installed in the target database. We identify
1990 * such extensions by their having OIDs in the range reserved for initdb.
1991 * We dump all user-added extensions by default. No extensions are dumped
1992 * if include_everything is false (i.e., a --schema or --table switch was
1993 * given), except if --extension specifies a list of extensions to dump.
1994 */
1995 static void
1997 {
1998 /*
1999 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2000 * change permissions on their member objects, if they wish to, and have
2001 * those changes preserved.
2002 */
2005 else
2006 {
2007 /* check if there is a list of extensions to dump */
2013 else
2017 }
2018 }
2020 /*
2021 * selectDumpablePublicationObject: policy-setting subroutine
2022 * Mark a publication object as to be dumped or not
2023 *
2024 * A publication can have schemas and tables which have schemas, but those are
2025 * ignored in decision making, because publications are only dumped when we are
2026 * dumping everything.
2027 */
2028 static void
2030 {
2036 }
2038 /*
2039 * selectDumpableObject: policy-setting subroutine
2040 * Mark a generic dumpable object as to be dumped or not
2041 *
2042 * Use this only for object types without a special-case routine above.
2043 */
2044 static void
2046 {
2050 /*
2051 * Default policy is to dump if parent namespace is dumpable, or for
2052 * non-namespace-associated items, dump if we're dumping "everything".
2053 */
2056 else
2059 }
2061 /*
2062 * Dump a table's contents for loading using the COPY command
2063 * - this routine is called by the Archiver when it wants the table
2064 * to be dumped.
2065 */
2066 static int
2068 {
2074 /*
2075 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2076 * which uses it already.
2077 */
2088 /*
2089 * Specify the column list explicitly so that we have no possibility of
2090 * retrieving data in the wrong column order. (The default column
2091 * ordering of COPY will not be what we want in certain corner cases
2092 * involving ADD COLUMN and inheritance.)
2093 */
2096 /*
2097 * Use COPY (SELECT ...) TO when dumping a foreign table's data, and when
2098 * a filter condition was specified. For other cases a simple COPY
2099 * suffices.
2100 */
2102 {
2104 /* klugery to get rid of parens in column list */
2106 {
2109 }
2110 else
2116 }
2117 else
2118 {
2121 column_list);
2122 }
2128 {
2135 {
2138 }
2140 /* ----------
2141 * THROTTLE:
2142 *
2143 * There was considerable discussion in late July, 2000 regarding
2144 * slowing down pg_dump when backing up large tables. Users with both
2145 * slow & fast (multi-processor) machines experienced performance
2146 * degradation when doing a backup.
2147 *
2148 * Initial attempts based on sleeping for a number of ms for each ms
2149 * of work were deemed too complex, then a simple 'sleep in each loop'
2150 * implementation was suggested. The latter failed because the loop
2151 * was too tight. Finally, the following was implemented:
2152 *
2153 * If throttle is non-zero, then
2154 * See how long since the last sleep.
2155 * Work out how long to sleep (based on ratio).
2156 * If sleep is more than 100ms, then
2157 * sleep
2158 * reset timer
2159 * EndIf
2160 * EndIf
2161 *
2162 * where the throttle value was the number of ms to sleep per ms of
2163 * work. The calculation was done in each loop.
2164 *
2165 * Most of the hard work is done in the backend, and this solution
2166 * still did not work particularly well: on slow machines, the ratio
2167 * was 50:1, and on medium paced machines, 1:1, and on fast
2168 * multi-processor machines, it had little or no effect, for reasons
2169 * that were unclear.
2170 *
2171 * Further discussion ensued, and the proposal was dropped.
2172 *
2173 * For those people who want this feature, it can be implemented using
2174 * gettimeofday in each loop, calculating the time since last sleep,
2175 * multiplying that by the sleep ratio, then if the result is more
2176 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2177 * function to sleep for a subsecond period ie.
2178 *
2179 * select(0, NULL, NULL, NULL, &tvi);
2180 *
2181 * This will return after the interval specified in the structure tvi.
2182 * Finally, call gettimeofday again to save the 'last sleep time'.
2183 * ----------
2184 */
2185 }
2189 {
2190 /* copy data transfer failed */
2191 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2195 }
2197 /* Check command status and return to normal libpq state */
2200 {
2205 }
2208 /* Do this to ensure we've pumped libpq back to idle state */
2211 classname);
2215 }
2217 /*
2218 * Dump table data using INSERT commands.
2219 *
2220 * Caution: when we restore from an archive file direct to database, the
2221 * INSERT commands emitted by this function have to be parsed by
2222 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
2223 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
2224 */
2225 static int
2227 {
2236 i;
2240 /*
2241 * If we're going to emit INSERTs with column names, the most efficient
2242 * way to deal with generated columns is to exclude them entirely. For
2243 * INSERTs without column names, we have to emit DEFAULT rather than the
2244 * actual column value --- but we can save a few cycles by fetching nulls
2245 * rather than the uninteresting-to-us value.
2246 */
2251 {
2260 else
2263 nfields++;
2264 }
2265 /* Servers before 9.4 will complain about zero-column SELECT */
2276 {
2278 PGRES_TUPLES_OK);
2280 /* cross-check field count, allowing for dummy NULL if any */
2286 /*
2287 * First time through, we build as much of the INSERT statement as
2288 * possible in "insertStmt", which we can then just print for each
2289 * statement. If the table happens to have zero dumpable columns then
2290 * this will be a complete statement, otherwise it will end in
2291 * "VALUES" and be ready to have the row's column values printed.
2292 */
2294 {
2299 /*
2300 * When load-via-partition-root is set or forced, get the root
2301 * table name for the partition table, so that we can reload data
2302 * through the root table.
2303 */
2308 else
2314 /* corner case for zero-column table */
2316 {
2318 }
2319 else
2320 {
2321 /* append the list of column names if required */
2323 {
2326 {
2331 }
2333 }
2339 }
2340 }
2343 {
2344 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2348 /*
2349 * If it is zero-column table then we've already written the
2350 * complete statement, which will mean we've disobeyed
2351 * --rows-per-insert when it's set greater than 1. We do support
2352 * a way to make this multi-row with: SELECT UNION ALL SELECT
2353 * UNION ALL ... but that's non-standard so we should avoid it
2354 * given that using INSERTs is mostly only ever needed for
2355 * cross-database exports.
2356 */
2360 /* Emit a row heading */
2365 else
2369 {
2373 {
2376 }
2378 {
2381 }
2383 /* XXX This code is partially duplicated in ruleutils.c */
2385 {
2393 {
2394 /*
2395 * These types are printed without quotes unless
2396 * they contain values that aren't accepted by the
2397 * scanner unquoted (e.g., 'NaN'). Note that
2398 * strtod() and friends might accept NaN, so we
2399 * can't use that to test.
2400 *
2401 * In reality we only need to defend against
2402 * infinity and NaN, so we need not get too crazy
2403 * about pattern matching here.
2404 */
2409 else
2411 }
2423 else
2428 /* All other types are printed as string literals. */
2432 fout);
2435 }
2436 }
2438 /* Terminate the row ... */
2441 /* ... and the statement, if the target no. of rows is reached */
2443 {
2446 else
2448 /* Reset the row counter */
2450 }
2451 }
2454 {
2457 }
2459 }
2461 /* Terminate any statements that didn't make the row count. */
2463 {
2466 else
2468 }
2480 }
2482 /*
2483 * getRootTableInfo:
2484 * get the root TableInfo for the given partition table.
2485 */
2488 {
2496 {
2499 }
2502 }
2504 /*
2505 * forcePartitionRootLoad
2506 * Check if we must force load_via_partition_root for this partition.
2507 *
2508 * This is required if any level of ancestral partitioned table has an
2509 * unsafe partitioning scheme.
2510 */
2511 static bool
2513 {
2523 {
2528 }
2531 }
2533 /*
2534 * dumpTableData -
2535 * dump the contents of a single table
2536 *
2537 * Actually, this just makes an ArchiveEntry for the table contents.
2538 */
2539 static void
2541 {
2546 DataDumperPtr dumpFn;
2551 /* We had better have loaded per-column details about this table */
2554 /*
2555 * When load-via-partition-root is set or forced, get the root table name
2556 * for the partition table, so that we can reload data through the root
2557 * table. Then construct a comment to be inserted into the TOC entry's
2558 * defn field, so that such cases can be identified reliably.
2559 */
2563 {
2569 copyFrom);
2571 }
2572 else
2576 {
2577 /* Dump/restore using COPY */
2579 /* must use 2 steps here 'cause fmtId is nonreentrant */
2581 copyFrom);
2585 }
2586 else
2587 {
2588 /* Restore using INSERT */
2591 }
2593 /*
2594 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2595 * dependency on its table as "special" and pass it to ArchiveEntry now.
2596 * See comments for BuildArchiveDependencies.
2597 */
2599 {
2615 /*
2616 * Set the TocEntry's dataLength in case we are doing a parallel dump
2617 * and want to order dump jobs by table size. We choose to measure
2618 * dataLength in table pages (including TOAST pages) during dump, so
2619 * no scaling is needed.
2620 *
2621 * However, relpages is declared as "integer" in pg_class, and hence
2622 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2623 * Cast so that we get the right interpretation of table sizes
2624 * exceeding INT_MAX pages.
2625 */
2629 /*
2630 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2631 * and instead we'd better worry about integer overflow. Clamp to
2632 * INT_MAX if the correct result exceeds that.
2633 */
2638 }
2642 }
2644 /*
2645 * refreshMatViewData -
2646 * load or refresh the contents of a single materialized view
2647 *
2648 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2649 * statement.
2650 */
2651 static void
2653 {
2655 PQExpBuffer q;
2657 /* If the materialized view is not flagged as populated, skip this. */
2680 }
2682 /*
2683 * getTableData -
2684 * set up dumpable objects representing the contents of tables
2685 */
2686 static void
2688 {
2692 {
2696 }
2697 }
2699 /*
2700 * Make a dumpable object for the data of this specific table
2701 *
2702 * Note: we make a TableDataInfo if and only if we are going to dump the
2703 * table data; the "dump" field in such objects isn't very interesting.
2704 */
2705 static void
2707 {
2710 /*
2711 * Nothing to do if we already decided to dump the table. This will
2712 * happen for "config" tables.
2713 */
2717 /* Skip VIEWs (no data to dump) */
2720 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
2726 /* Skip partitioned tables (data in partitions) */
2730 /* Don't dump data in unlogged tables, if so requested */
2735 /* Check that the data is not explicitly excluded */
2740 /* OK, let's dump it */
2747 else
2750 /*
2751 * Note: use tableoid 0 so that this object won't be mistaken for
2752 * something that pg_depend entries apply to.
2753 */
2763 /* A TableDataInfo contains data, of course */
2768 /* Make sure that we'll collect per-column info for this table. */
2770 }
2772 /*
2773 * The refresh for a materialized view must be dependent on the refresh for
2774 * any materialized view that this one is dependent on.
2775 *
2776 * This must be called after all the objects are created, but before they are
2777 * sorted.
2778 */
2779 static void
2781 {
2782 PQExpBuffer query;
2785 i;
2787 i_objid,
2788 i_refobjid;
2790 /* No Mat Views before 9.3. */
2797 "( "
2798 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
2799 "FROM pg_depend d1 "
2800 "JOIN pg_class c1 ON c1.oid = d1.objid "
2802 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
2803 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
2804 "AND d2.objid = r1.oid "
2805 "AND d2.refobjid <> d1.objid "
2806 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
2809 "WHERE d1.classid = 'pg_class'::regclass "
2810 "UNION "
2811 "SELECT w.objid, d3.refobjid, c3.relkind "
2812 "FROM w "
2813 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
2814 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
2815 "AND d3.objid = r3.oid "
2816 "AND d3.refobjid <> w.refobjid "
2817 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
2820 ") "
2821 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
2822 "FROM w "
2834 {
2835 CatalogId objId;
2836 CatalogId refobjId;
2875 }
2880 }
2882 /*
2883 * getTableDataFKConstraints -
2884 * add dump-order dependencies reflecting foreign key constraints
2885 *
2886 * This code is executed only in a data-only dump --- in schema+data dumps
2887 * we handle foreign key issues by not creating the FK constraints until
2888 * after the data is loaded. In a data-only dump, however, we want to
2889 * order the table data objects in such a way that a table's referenced
2890 * tables are restored first. (In the presence of circular references or
2891 * self-references this may be impossible; we'll detect and complain about
2892 * that during the dependency sorting step.)
2893 */
2894 static void
2896 {
2901 /* Search through all the dumpable objects for FK constraints */
2904 {
2906 {
2910 /* Not interesting unless both tables are to be dumped */
2919 /*
2920 * Okay, make referencing table's TABLE_DATA object depend on the
2921 * referenced table's TABLE_DATA object.
2922 */
2925 }
2926 }
2928 }
2931 /*
2932 * dumpDatabase:
2933 * dump the database definition
2934 */
2935 static void
2937 {
2946 i_oid,
2947 i_datname,
2948 i_datdba,
2949 i_encoding,
2950 i_datlocprovider,
2951 i_collate,
2952 i_ctype,
2953 i_daticulocale,
2954 i_daticurules,
2955 i_frozenxid,
2956 i_minmxid,
2957 i_datacl,
2958 i_acldefault,
2959 i_datistemplate,
2960 i_datconnlimit,
2961 i_datcollversion,
2962 i_tablespace;
2963 CatalogId dbCatId;
2964 DumpId dbDumpId;
2965 DumpableAcl dbdacl;
2977 uint32 frozenxid,
2978 minmxid;
2983 /*
2984 * Fetch the database-level properties for this database.
2985 */
2987 "datdba, "
2988 "pg_encoding_to_char(encoding) AS encoding, "
2989 "datcollate, datctype, datfrozenxid, "
2990 "datacl, acldefault('d', datdba) AS acldefault, "
2994 else
2998 else
2999 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS daticulocale, NULL AS datcollversion, ");
3002 else
3005 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3006 "shobj_description(oid, 'pg_database') AS description "
3007 "FROM pg_database "
3041 else
3045 else
3057 /*
3058 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3059 * to preserve that), as well as the encoding, locale, and tablespace
3060 * since those can't be altered later. Other DB properties are left to
3061 * the DATABASE PROPERTIES entry, so that they can be applied after
3062 * reconnecting to the target DB.
3063 */
3065 {
3068 }
3069 else
3070 {
3072 qdatname);
3073 }
3075 {
3078 }
3085 else
3087 datlocprovider);
3090 {
3093 }
3094 else
3095 {
3097 {
3100 }
3102 {
3105 }
3106 }
3108 {
3111 }
3113 {
3116 }
3118 /*
3119 * For binary upgrade, carry over the collation version. For normal
3120 * dump/restore, omit the version, so that it is computed upon restore.
3121 */
3123 {
3125 {
3129 fout);
3130 }
3131 }
3133 /*
3134 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3135 * thing; the decision whether to specify a tablespace should be left till
3136 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3137 * label the DATABASE entry with the tablespace and let the normal
3138 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3139 * attention to default_tablespace, so that won't work.
3140 */
3148 qdatname);
3162 /* Compute correct tag for archive entry */
3165 /* Dump DB comment if any */
3166 {
3167 /*
3168 * 8.2 and up keep comments on shared objects in a shared table, so we
3169 * cannot use the dumpComment() code used for other database objects.
3170 * Be careful that the ArchiveEntry parameters match that function.
3171 */
3175 {
3178 /*
3179 * Generates warning when loaded into a differently-named
3180 * database.
3181 */
3194 }
3195 }
3197 /* Dump DB security label, if enabled */
3199 {
3201 PQExpBuffer seclabelQry;
3220 }
3222 /*
3223 * Dump ACL if any. Note that we do not support initial privileges
3224 * (pg_init_privs) on databases.
3225 */
3233 /*
3234 * Now construct a DATABASE PROPERTIES archive entry to restore any
3235 * non-default database-level properties. (The reason this must be
3236 * separate is that we cannot put any additional commands into the TOC
3237 * entry that has CREATE DATABASE. pg_restore would execute such a group
3238 * in an implicit transaction block, and the backend won't allow CREATE
3239 * DATABASE in that context.)
3240 */
3249 {
3251 qdatname);
3253 /*
3254 * The backend won't accept DROP DATABASE on a template database. We
3255 * can deal with that by removing the template marking before the DROP
3256 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3257 * since no such command is currently supported, fake it with a direct
3258 * UPDATE on pg_database.
3259 */
3264 }
3266 /*
3267 * We do not restore pg_database.dathasloginevt because it is set
3268 * automatically on login event trigger creation.
3269 */
3271 /* Add database-specific SET options */
3274 /*
3275 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3276 * entry, too, for lack of a better place.
3277 */
3279 {
3287 }
3299 /*
3300 * pg_largeobject comes from the old system intact, so set its
3301 * relfrozenxids, relminmxids and relfilenode.
3302 */
3304 {
3310 ii_relfilenode,
3311 ii_oid,
3312 ii_relminmxid;
3314 /*
3315 * pg_largeobject
3316 */
3322 else
3335 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3336 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3338 {
3339 Oid oid;
3340 RelFileNumber relfilenumber;
3355 relfilenumber);
3359 relfilenumber);
3360 }
3377 }
3386 }
3388 /*
3389 * Collect any database-specific or role-and-database-specific SET options
3390 * for this database, and append them to outbuf.
3391 */
3392 static void
3395 {
3400 /* First collect database-specific options */
3403 dboid);
3410 outbuf);
3414 /* Now look for role-and-database-specific options */
3416 "FROM pg_db_role_setting s, pg_roles r "
3418 dboid);
3426 outbuf);
3431 }
3433 /*
3434 * dumpEncoding: put the correct encoding into the archive
3435 */
3436 static void
3438 {
3455 }
3458 /*
3459 * dumpStdStrings: put the correct escape string behavior into the archive
3460 */
3461 static void
3463 {
3468 stdstrings);
3471 stdstrings);
3480 }
3482 /*
3483 * dumpSearchPath: record the active search_path in the archive
3484 */
3485 static void
3487 {
3495 /*
3496 * We use the result of current_schemas(), not the search_path GUC,
3497 * because that might contain wildcards such as "$user", which won't
3498 * necessarily have the same value during restore. Also, this way avoids
3499 * listing schemas that may appear in search_path but not actually exist,
3500 * which seems like a prudent exclusion.
3501 */
3508 /*
3509 * We use set_config(), not a simple "SET search_path" command, because
3510 * the latter has less-clean behavior if the search path is empty. While
3511 * that's likely to get fixed at some point, it seems like a good idea to
3512 * be as backwards-compatible as possible in what we put into archives.
3513 */
3515 {
3519 }
3533 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3540 }
3543 /*
3544 * getLOs:
3545 * Collect schema-level data about large objects
3546 */
3547 static void
3549 {
3564 /* Fetch LO OIDs, and owner/ACL data */
3566 "SELECT oid, lomowner, lomacl, "
3567 "acldefault('L', lomowner) AS acldefault "
3579 /*
3580 * Each large object has its own "BLOB" archive entry.
3581 */
3585 {
3598 /* LOs have data */
3601 /* Mark whether LO has an ACL */
3605 /*
3606 * In binary-upgrade mode for LOs, we do *not* dump out the LO data,
3607 * as it will be copied by pg_upgrade, which simply copies the
3608 * pg_largeobject table. We *do* however dump out anything but the
3609 * data, as pg_upgrade copies just pg_largeobject, but not
3610 * pg_largeobject_metadata, after the dump is restored.
3611 */
3614 }
3616 /*
3617 * If we have any large objects, a "BLOBS" archive entry is needed. This
3618 * is just a placeholder for sorting; it carries no data now.
3619 */
3621 {
3628 }
3632 }
3634 /*
3635 * dumpLO
3636 *
3637 * dump the definition (metadata) of the given large object
3638 */
3639 static void
3641 {
3662 /* Dump comment if any */
3668 /* Dump security label if any */
3674 /* Dump ACL if any */
3682 }
3684 /*
3685 * dumpLOs:
3686 * dump the data contents of all large objects
3687 */
3688 static int
3690 {
3702 /*
3703 * Currently, we re-fetch all LO OIDs using a cursor. Consider scanning
3704 * the already-in-memory dumpable objects instead...
3705 */
3706 loQry =
3707 "DECLARE looid CURSOR FOR "
3712 /* Command to fetch from cursor */
3715 do
3716 {
3717 /* Do a fetch */
3720 /* Process the tuples, if any */
3723 {
3724 Oid loOid;
3728 /* Open the LO */
3736 /* Now read it in chunks, sending data to archive */
3737 do
3738 {
3750 }
3756 }
3758 /*
3759 * getPolicies
3760 * get information about all RLS policies on dumpable tables.
3761 */
3762 void
3764 {
3765 PQExpBuffer query;
3766 PQExpBuffer tbloids;
3779 j,
3780 ntups;
3782 /* No policies before 9.5 */
3789 /*
3790 * Identify tables of interest, and check which ones have RLS enabled.
3791 */
3794 {
3797 /* Ignore row security on tables not to be dumped */
3801 /* It can't have RLS or policies if it's not a table */
3806 /* Add it to the list of table OIDs to be probed below */
3811 /* Is RLS enabled? (That's separate from whether it has policies) */
3813 {
3816 /*
3817 * We represent RLS being enabled on a table by creating a
3818 * PolicyInfo object with null polname.
3819 *
3820 * Note: use tableoid 0 so that this object won't be mistaken for
3821 * something that pg_depend entries apply to.
3822 */
3837 }
3838 }
3841 /*
3842 * Now, read all RLS policies belonging to the tables of interest, and
3843 * create PolicyInfo objects for them. (Note that we must filter the
3844 * results server-side not locally, because we dare not apply pg_get_expr
3845 * to tables we don't have lock on.)
3846 */
3853 else
3856 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
3857 " 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, "
3858 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
3859 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
3868 {
3882 {
3903 else
3908 else
3913 else
3916 }
3917 }
3923 }
3925 /*
3926 * dumpPolicy
3927 * dump the definition of the given policy
3928 */
3929 static void
3931 {
3934 PQExpBuffer query;
3935 PQExpBuffer delqry;
3936 PQExpBuffer polprefix;
3941 /* Do nothing in data-only dump */
3945 /*
3946 * If polname is NULL, then this record is just indicating that ROW LEVEL
3947 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
3948 * ROW LEVEL SECURITY.
3949 */
3951 {
3957 /*
3958 * We must emit the ROW SECURITY object's dependency on its table
3959 * explicitly, because it will not match anything in pg_depend (unlike
3960 * the case for other PolicyInfo objects).
3961 */
3975 }
3987 else
4041 }
4043 /*
4044 * getPublications
4045 * get information about publications
4046 */
4047 PublicationInfo *
4049 {
4051 PQExpBuffer query;
4065 ntups;
4068 {
4071 }
4077 /* Get the publications. */
4080 "SELECT p.tableoid, p.oid, p.pubname, "
4081 "p.pubowner, "
4082 "p.puballtables, p.pubinsert, p.pubupdate, p.pubdelete, p.pubtruncate, p.pubviaroot "
4086 "SELECT p.tableoid, p.oid, p.pubname, "
4087 "p.pubowner, "
4088 "p.puballtables, p.pubinsert, p.pubupdate, p.pubdelete, p.pubtruncate, false AS pubviaroot "
4090 else
4092 "SELECT p.tableoid, p.oid, p.pubname, "
4093 "p.pubowner, "
4094 "p.puballtables, p.pubinsert, p.pubupdate, p.pubdelete, false AS pubtruncate, false AS pubviaroot "
4115 {
4136 /* Decide whether we want to dump it */
4138 }
4145 }
4147 /*
4148 * dumpPublication
4149 * dump the definition of the given publication
4150 */
4151 static void
4153 {
4155 PQExpBuffer delq;
4156 PQExpBuffer query;
4160 /* Do nothing in data-only dump */
4170 qpubname);
4173 qpubname);
4180 {
4183 }
4186 {
4192 }
4195 {
4201 }
4204 {
4210 }
4241 }
4243 /*
4244 * getPublicationNamespaces
4245 * get information about publication membership for dumpable schemas.
4246 */
4247 void
4249 {
4250 PQExpBuffer query;
4259 j,
4260 ntups;
4267 /* Collect all publication membership info. */
4269 "SELECT tableoid, oid, pnpubid, pnnspid "
4280 /* this allocation may be more than we need */
4285 {
4291 /*
4292 * Ignore any entries for which we aren't interested in either the
4293 * publication or the rel.
4294 */
4302 /*
4303 * We always dump publication namespaces unless the corresponding
4304 * namespace is excluded from the dump.
4305 */
4309 /* OK, make a DumpableObject for this relationship */
4320 /* Decide whether we want to dump it */
4323 j++;
4324 }
4328 }
4330 /*
4331 * getPublicationTables
4332 * get information about publication membership for dumpable tables.
4333 */
4334 void
4336 {
4337 PQExpBuffer query;
4348 j,
4349 ntups;
4356 /* Collect all publication membership info. */
4359 "SELECT tableoid, oid, prpubid, prrelid, "
4360 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4365 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4368 " ELSE NULL END) prattrs "
4370 else
4372 "SELECT tableoid, oid, prpubid, prrelid, "
4373 "NULL AS prrelqual, NULL AS prattrs "
4386 /* this allocation may be more than we need */
4391 {
4397 /*
4398 * Ignore any entries for which we aren't interested in either the
4399 * publication or the rel.
4400 */
4408 /*
4409 * Ignore publication membership of tables whose definitions are not
4410 * to be dumped.
4411 */
4415 /* OK, make a DumpableObject for this relationship */
4427 else
4431 {
4434 PQExpBuffer attribs;
4441 {
4446 }
4448 }
4449 else
4452 /* Decide whether we want to dump it */
4455 j++;
4456 }
4460 }
4462 /*
4463 * dumpPublicationNamespace
4464 * dump the definition of the given publication schema mapping.
4465 */
4466 static void
4468 {
4472 PQExpBuffer query;
4475 /* Do nothing in data-only dump */
4486 /*
4487 * There is no point in creating drop query as the drop is done by schema
4488 * drop.
4489 */
4499 /* These objects can't currently have comments or seclabels */
4503 }
4505 /*
4506 * dumpPublicationTable
4507 * dump the definition of the given publication table mapping
4508 */
4509 static void
4511 {
4515 PQExpBuffer query;
4518 /* Do nothing in data-only dump */
4535 {
4536 /*
4537 * It's necessary to add parentheses around the expression because
4538 * pg_get_expr won't supply the parentheses for things like WHERE
4539 * TRUE.
4540 */
4542 }
4545 /*
4546 * There is no point in creating a drop query as the drop is done by table
4547 * drop. (If you think to change this, see also _printTocEntry().)
4548 * Although this object doesn't really have ownership as such, set the
4549 * owner field anyway to ensure that the command is run by the correct
4550 * role at restore time.
4551 */
4561 /* These objects can't currently have comments or seclabels */
4565 }
4567 /*
4568 * Is the currently connected user a superuser?
4569 */
4570 static bool
4572 {
4582 }
4584 /*
4585 * getSubscriptions
4586 * get information about subscriptions
4587 */
4588 void
4590 {
4592 PQExpBuffer query;
4611 ntups;
4617 {
4621 "SELECT count(*) FROM pg_subscription "
4622 "WHERE subdbid = (SELECT oid FROM pg_database"
4624 PGRES_TUPLES_OK);
4630 }
4634 /* Get the subscriptions in current database. */
4643 else
4648 else
4655 else
4659 LOGICALREP_TWOPHASE_STATE_DISABLED);
4666 else
4671 LOGICALREP_ORIGIN_ANY);
4682 /*
4683 * Get subscription fields. We don't include subskiplsn in the dump as
4684 * after restoring the dump this value may no longer be relevant.
4685 */
4705 {
4730 else
4739 /* Decide whether we want to dump it */
4741 }
4745 }
4747 /*
4748 * dumpSubscription
4749 * dump the definition of the given subscription
4750 */
4751 static void
4753 {
4755 PQExpBuffer delq;
4756 PQExpBuffer query;
4757 PQExpBuffer publications;
4764 /* Do nothing in data-only dump */
4774 qsubname);
4777 qsubname);
4780 /* Build list of quoted publications and append them to query. */
4786 {
4791 }
4793 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
4796 else
4852 }
4854 /*
4855 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
4856 * the object needs.
4857 */
4858 static void
4860 PQExpBuffer create,
4865 {
4867 {
4870 PQExpBuffer query;
4875 /* dodge fmtId() non-reentrancy */
4880 "SELECT e.extname "
4881 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
4882 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
4883 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
4885 catalog,
4891 {
4895 }
4900 }
4901 }
4903 static Oid
4905 {
4906 /*
4907 * If the old version didn't assign an array type, but the new version
4908 * does, we must select an unused type OID to assign. This currently only
4909 * happens for domains, when upgrading pre-v11 to v11 and up.
4910 *
4911 * Note: local state here is kind of ugly, but we must have some, since we
4912 * mustn't choose the same unused OID more than once.
4913 */
4918 do
4919 {
4922 "SELECT EXISTS(SELECT 1 "
4923 "FROM pg_catalog.pg_type "
4925 next_possible_free_oid);
4932 }
4934 static void
4936 PQExpBuffer upgrade_buffer,
4937 Oid pg_type_oid,
4940 {
4943 Oid pg_type_array_oid;
4944 Oid pg_type_multirange_oid;
4945 Oid pg_type_multirange_array_oid;
4950 pg_type_oid);
4953 "SELECT typarray "
4954 "FROM pg_catalog.pg_type "
4956 pg_type_oid);
4968 {
4973 pg_type_array_oid);
4974 }
4976 /*
4977 * Pre-set the multirange type oid and its own array type oid.
4978 */
4980 {
4982 {
4984 "SELECT t.oid, t.typarray "
4985 "FROM pg_catalog.pg_type t "
4986 "JOIN pg_catalog.pg_range r "
4987 "ON t.oid = r.rngmultitypid "
4989 pg_type_oid);
4997 }
4998 else
4999 {
5002 }
5008 pg_type_multirange_oid);
5012 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5013 pg_type_multirange_array_oid);
5014 }
5017 }
5019 static void
5021 PQExpBuffer upgrade_buffer,
5023 {
5029 }
5031 static void
5035 {
5038 RelFileNumber relfilenumber;
5039 Oid toast_oid;
5040 RelFileNumber toast_relfilenumber;
5042 Oid toast_index_oid;
5043 RelFileNumber toast_index_relfilenumber;
5045 /*
5046 * Preserve the OID and relfilenumber of the table, table's index, table's
5047 * toast table and toast table's index if any.
5048 *
5049 * One complexity is that the current table definition might not require
5050 * the creation of a TOAST table, but the old database might have a TOAST
5051 * table that was created earlier, before some wide columns were dropped.
5052 * By setting the TOAST oid we force creation of the TOAST heap and index
5053 * by the new backend, so we can copy the files during binary upgrade
5054 * without worrying about this case.
5055 */
5057 "SELECT c.relkind, c.relfilenode, c.reltoastrelid, ct.relfilenode AS toast_relfilenode, i.indexrelid, cti.relfilenode AS toast_index_relfilenode "
5058 "FROM pg_catalog.pg_class c LEFT JOIN "
5059 "pg_catalog.pg_index i ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5060 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5061 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5063 pg_class_oid);
5084 {
5087 pg_class_oid);
5089 /*
5090 * Not every relation has storage. Also, in a pre-v12 database,
5091 * partitioned tables have a relfilenumber, which should not be
5092 * preserved when upgrading.
5093 */
5097 relfilenumber);
5099 /*
5100 * In a pre-v12 database, partitioned tables might be marked as having
5101 * toast tables, but we should ignore them if so.
5102 */
5105 {
5108 toast_oid);
5111 toast_relfilenumber);
5113 /* every toast table has an index */
5116 toast_index_oid);
5119 toast_index_relfilenumber);
5120 }
5123 }
5124 else
5125 {
5126 /* Preserve the OID and relfilenumber of the index */
5129 pg_class_oid);
5132 relfilenumber);
5133 }
5138 }
5140 /*
5141 * If the DumpableObject is a member of an extension, add a suitable
5142 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
5143 *
5144 * For somewhat historical reasons, objname should already be quoted,
5145 * but not objnamespace (if any).
5146 */
5147 static void
5153 {
5160 /*
5161 * Find the parent extension. We could avoid this search if we wanted to
5162 * add a link field to DumpableObject, but the space costs of that would
5163 * be considerable. We assume that member objects could only have a
5164 * direct dependency on their own extension, not any others.
5165 */
5167 {
5172 }
5181 objtype);
5185 }
5187 /*
5188 * getNamespaces:
5189 * read all namespaces in the system catalogs and return them in the
5190 * NamespaceInfo* structure
5191 *
5192 * numNamespaces is set to the number of namespaces read in
5193 */
5194 NamespaceInfo *
5196 {
5200 PQExpBuffer query;
5211 /*
5212 * we fetch all namespaces including system ones, so that every object we
5213 * read in can be linked to a containing namespace.
5214 */
5216 "n.nspowner, "
5217 "n.nspacl, "
5218 "acldefault('n', n.nspowner) AS acldefault "
5235 {
5251 /* Decide whether to dump this namespace */
5254 /* Mark whether namespace has an ACL */
5258 /*
5259 * We ignore any pg_init_privs.initprivs entry for the public schema
5260 * and assume a predetermined default, for several reasons. First,
5261 * dropping and recreating the schema removes its pg_init_privs entry,
5262 * but an empty destination database starts with this ACL nonetheless.
5263 * Second, we support dump/reload of public schema ownership changes.
5264 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
5265 * initprivs continues to reflect the initial owner. Hence,
5266 * synthesize the value that nspacl will have after the restore's
5267 * ALTER SCHEMA OWNER. Third, this makes the destination database
5268 * match the source's ACL, even if the latter was an initdb-default
5269 * ACL, which changed in v15. An upgrade pulls in changes to most
5270 * system object ACLs that the DBA had not customized. We've made the
5271 * public schema depart from that, because changing its ACL so easily
5272 * breaks applications.
5273 */
5275 {
5279 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
5297 }
5298 }
5306 }
5308 /*
5309 * findNamespace:
5310 * given a namespace OID, look up the info read by getNamespaces
5311 */
5314 {
5321 }
5323 /*
5324 * getExtensions:
5325 * read all extensions in the system catalogs and return them in the
5326 * ExtensionInfo* structure
5327 *
5328 * numExtensions is set to the number of extensions read in
5329 */
5330 ExtensionInfo *
5332 {
5337 PQExpBuffer query;
5351 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
5352 "FROM pg_extension x "
5371 {
5383 /* Decide whether we want to dump it */
5385 }
5393 }
5395 /*
5396 * getTypes:
5397 * read all types in the system catalogs and return them in the
5398 * TypeInfo* structure
5399 *
5400 * numTypes is set to the number of types read in
5401 *
5402 * NB: this must run after getFuncs() because we assume we can do
5403 * findFuncByOid().
5404 */
5405 TypeInfo *
5407 {
5428 /*
5429 * we include even the built-in types because those may be used as array
5430 * elements by user-defined types
5431 *
5432 * we filter out the built-in types when we dump out the types
5433 *
5434 * same approach for undefined (shell) types and array types
5435 *
5436 * Note: as of 8.3 we can reliably detect whether a type is an
5437 * auto-generated array type by checking the element type's typarray.
5438 * (Before that the test is capable of generating false positives.) We
5439 * still check for name beginning with '_', though, so as to avoid the
5440 * cost of the subselect probe for all standard types. This would have to
5441 * be revisited if the backend ever allows renaming of array types.
5442 */
5444 "typnamespace, typacl, "
5445 "acldefault('T', typowner) AS acldefault, "
5446 "typowner, "
5447 "typelem, typrelid, "
5449 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
5450 "typtype, typisdefined, "
5451 "typname[0] = '_' AND typelem != 0 AND "
5452 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
5476 {
5498 else
5503 else
5508 else
5511 /* Decide whether we want to dump it */
5514 /* Mark whether type has an ACL */
5518 /*
5519 * If it's a domain, fetch info about its constraints, if any
5520 */
5527 /*
5528 * If it's a base type, make a DumpableObject representing a shell
5529 * definition of the type. We will need to dump that ahead of the I/O
5530 * functions for the type. Similarly, range types need a shell
5531 * definition in case they have a canonicalize function.
5532 *
5533 * Note: the shell type doesn't have a catId. You might think it
5534 * should copy the base type's catId, but then it might capture the
5535 * pg_depend entries for the type, which we don't want.
5536 */
5540 {
5550 /*
5551 * Initially mark the shell type as not to be dumped. We'll only
5552 * dump it if the I/O or canonicalize functions need to be dumped;
5553 * this is taken care of while sorting dependencies.
5554 */
5556 }
5557 }
5566 }
5568 /*
5569 * getOperators:
5570 * read all operators in the system catalogs and return them in the
5571 * OprInfo* structure
5572 *
5573 * numOprs is set to the number of operators read in
5574 */
5575 OprInfo *
5577 {
5591 /*
5592 * find all operators, including builtin operators; we filter out
5593 * system-defined operators at dump-out time.
5594 */
5597 "oprnamespace, "
5598 "oprowner, "
5599 "oprkind, "
5600 "oprcode::oid AS oprcode "
5619 {
5631 /* Decide whether we want to dump it */
5633 }
5640 }
5642 /*
5643 * getCollations:
5644 * read all collations in the system catalogs and return them in the
5645 * CollInfo* structure
5646 *
5647 * numCollations is set to the number of collations read in
5648 */
5649 CollInfo *
5651 {
5655 PQExpBuffer query;
5665 /*
5666 * find all collations, including builtin collations; we filter out
5667 * system-defined collations at dump-out time.
5668 */
5671 "collnamespace, "
5672 "collowner "
5689 {
5699 /* Decide whether we want to dump it */
5701 }
5708 }
5710 /*
5711 * getConversions:
5712 * read all conversions in the system catalogs and return them in the
5713 * ConvInfo* structure
5714 *
5715 * numConversions is set to the number of conversions read in
5716 */
5717 ConvInfo *
5719 {
5723 PQExpBuffer query;
5733 /*
5734 * find all conversions, including builtin conversions; we filter out
5735 * system-defined conversions at dump-out time.
5736 */
5739 "connamespace, "
5740 "conowner "
5757 {
5767 /* Decide whether we want to dump it */
5769 }
5776 }
5778 /*
5779 * getAccessMethods:
5780 * read all user-defined access methods in the system catalogs and return
5781 * them in the AccessMethodInfo* structure
5782 *
5783 * numAccessMethods is set to the number of access methods read in
5784 */
5785 AccessMethodInfo *
5787 {
5791 PQExpBuffer query;
5799 /* Before 9.6, there are no user-defined access methods */
5801 {
5804 }
5808 /* Select all access methods from pg_am table */
5810 "amhandler::pg_catalog.regproc AS amhandler "
5827 {
5837 /* Decide whether we want to dump it */
5839 }
5846 }
5849 /*
5850 * getOpclasses:
5851 * read all opclasses in the system catalogs and return them in the
5852 * OpclassInfo* structure
5853 *
5854 * numOpclasses is set to the number of opclasses read in
5855 */
5856 OpclassInfo *
5858 {
5870 /*
5871 * find all opclasses, including builtin opclasses; we filter out
5872 * system-defined opclasses at dump-out time.
5873 */
5876 "opcnamespace, "
5877 "opcowner "
5894 {
5904 /* Decide whether we want to dump it */
5906 }
5913 }
5915 /*
5916 * getOpfamilies:
5917 * read all opfamilies in the system catalogs and return them in the
5918 * OpfamilyInfo* structure
5919 *
5920 * numOpfamilies is set to the number of opfamilies read in
5921 */
5922 OpfamilyInfo *
5924 {
5928 PQExpBuffer query;
5938 /*
5939 * find all opfamilies, including builtin opfamilies; we filter out
5940 * system-defined opfamilies at dump-out time.
5941 */
5944 "opfnamespace, "
5945 "opfowner "
5962 {
5972 /* Decide whether we want to dump it */
5974 }
5981 }
5983 /*
5984 * getAggregates:
5985 * read all the user-defined aggregates in the system catalogs and
5986 * return them in the AggInfo* structure
5987 *
5988 * numAggs is set to the number of aggregates read in
5989 */
5990 AggInfo *
5992 {
6009 /*
6010 * Find all interesting aggregates. See comment in getFuncs() for the
6011 * rationale behind the filtering logic.
6012 */
6014 {
6021 "p.proname AS aggname, "
6022 "p.pronamespace AS aggnamespace, "
6023 "p.pronargs, p.proargtypes, "
6024 "p.proowner, "
6025 "p.proacl AS aggacl, "
6026 "acldefault('f', p.proowner) AS acldefault "
6027 "FROM pg_proc p "
6028 "LEFT JOIN pg_init_privs pip ON "
6029 "(p.oid = pip.objoid "
6030 "AND pip.classoid = 'pg_proc'::regclass "
6031 "AND pip.objsubid = 0) "
6032 "WHERE %s AND ("
6033 "p.pronamespace != "
6034 "(SELECT oid FROM pg_namespace "
6035 "WHERE nspname = 'pg_catalog') OR "
6037 agg_check);
6040 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6041 "classid = 'pg_proc'::regclass AND "
6042 "objid = p.oid AND "
6043 "refclassid = 'pg_extension'::regclass AND "
6046 }
6047 else
6048 {
6050 "pronamespace AS aggnamespace, "
6051 "pronargs, proargtypes, "
6052 "proowner, "
6053 "proacl AS aggacl, "
6054 "acldefault('f', proowner) AS acldefault "
6055 "FROM pg_proc p "
6056 "WHERE proisagg AND ("
6057 "pronamespace != "
6058 "(SELECT oid FROM pg_namespace "
6062 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6063 "classid = 'pg_proc'::regclass AND "
6064 "objid = p.oid AND "
6065 "refclassid = 'pg_extension'::regclass AND "
6068 }
6088 {
6106 else
6107 {
6112 }
6115 /* Decide whether we want to dump it */
6118 /* Mark whether aggregate has an ACL */
6121 }
6128 }
6130 /*
6131 * getFuncs:
6132 * read all the user-defined functions in the system catalogs and
6133 * return them in the FuncInfo* structure
6134 *
6135 * numFuncs is set to the number of functions read in
6136 */
6137 FuncInfo *
6139 {
6158 /*
6159 * Find all interesting functions. This is a bit complicated:
6160 *
6161 * 1. Always exclude aggregates; those are handled elsewhere.
6162 *
6163 * 2. Always exclude functions that are internally dependent on something
6164 * else, since presumably those will be created as a result of creating
6165 * the something else. This currently acts only to suppress constructor
6166 * functions for range types. Note this is OK only because the
6167 * constructors don't have any dependencies the range type doesn't have;
6168 * otherwise we might not get creation ordering correct.
6169 *
6170 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
6171 * they're members of extensions and we are in binary-upgrade mode then
6172 * include them, since we want to dump extension members individually in
6173 * that mode. Also, if they are used by casts or transforms then we need
6174 * to gather the information about them, though they won't be dumped if
6175 * they are built-in. Also, in 9.6 and up, include functions in
6176 * pg_catalog if they have an ACL different from what's shown in
6177 * pg_init_privs (so we have to join to pg_init_privs; annoying).
6178 */
6180 {
6187 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
6188 "p.pronargs, p.proargtypes, p.prorettype, "
6189 "p.proacl, "
6190 "acldefault('f', p.proowner) AS acldefault, "
6191 "p.pronamespace, "
6192 "p.proowner "
6193 "FROM pg_proc p "
6194 "LEFT JOIN pg_init_privs pip ON "
6195 "(p.oid = pip.objoid "
6196 "AND pip.classoid = 'pg_proc'::regclass "
6197 "AND pip.objsubid = 0) "
6198 "WHERE %s"
6200 "WHERE classid = 'pg_proc'::regclass AND "
6201 "objid = p.oid AND deptype = 'i')"
6204 "(SELECT oid FROM pg_namespace "
6205 "WHERE nspname = 'pg_catalog')"
6213 not_agg_check,
6214 g_last_builtin_oid,
6215 g_last_builtin_oid);
6219 "classid = 'pg_proc'::regclass AND "
6220 "objid = p.oid AND "
6221 "refclassid = 'pg_extension'::regclass AND "
6226 }
6227 else
6228 {
6230 "SELECT tableoid, oid, proname, prolang, "
6231 "pronargs, proargtypes, prorettype, proacl, "
6232 "acldefault('f', proowner) AS acldefault, "
6233 "pronamespace, "
6234 "proowner "
6235 "FROM pg_proc p "
6236 "WHERE NOT proisagg"
6238 "WHERE classid = 'pg_proc'::regclass AND "
6239 "objid = p.oid AND deptype = 'i')"
6242 "(SELECT oid FROM pg_namespace "
6243 "WHERE nspname = 'pg_catalog')"
6247 g_last_builtin_oid);
6255 g_last_builtin_oid);
6260 "classid = 'pg_proc'::regclass AND "
6261 "objid = p.oid AND "
6262 "refclassid = 'pg_extension'::regclass AND "
6265 }
6288 {
6306 else
6307 {
6311 }
6314 /* Decide whether we want to dump it */
6317 /* Mark whether function has an ACL */
6320 }
6327 }
6329 /*
6330 * getTables
6331 * read all the tables (no indexes) in the system catalogs,
6332 * and return them as an array of TableInfo structures
6333 *
6334 * *numTables is set to the number of tables read in
6335 */
6336 TableInfo *
6338 {
6383 /*
6384 * Find all the tables and table-like objects.
6385 *
6386 * We must fetch all tables in this phase because otherwise we cannot
6387 * correctly identify inherited columns, owned sequences, etc.
6388 *
6389 * We include system catalogs, so that we can work if a user table is
6390 * defined to inherit from a system catalog (pretty weird, but...)
6391 *
6392 * Note: in this phase we should collect only a minimal amount of
6393 * information about each table, basically just enough to decide if it is
6394 * interesting. In particular, since we do not yet have lock on any user
6395 * table, we MUST NOT invoke any server-side data collection functions
6396 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
6397 * wrong answers if any concurrent DDL is happening.
6398 */
6401 "SELECT c.tableoid, c.oid, c.relname, "
6402 "c.relnamespace, c.relkind, c.reltype, "
6403 "c.relowner, "
6404 "c.relchecks, "
6405 "c.relhasindex, c.relhasrules, c.relpages, "
6406 "c.relhastriggers, "
6407 "c.relpersistence, "
6408 "c.reloftype, "
6409 "c.relacl, "
6413 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
6414 "ELSE 0 END AS foreignserver, "
6415 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
6416 "tc.oid AS toid, "
6417 "tc.relpages AS toastpages, "
6418 "tc.reloptions AS toast_reloptions, "
6419 "d.refobjid AS owning_tab, "
6420 "d.refobjsubid AS owning_col, "
6426 else
6433 else
6440 else
6447 else
6449 "false AS relrowsecurity, "
6455 else
6461 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6462 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6463 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
6464 else
6471 else
6478 else
6485 else
6489 /*
6490 * Left join to pg_depend to pick up dependency info linking sequences to
6491 * their owning column, if any (note this dependency is AUTO except for
6492 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
6493 * collect the spcname.
6494 */
6497 "LEFT JOIN pg_depend d ON "
6499 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
6500 "d.objsubid = 0 AND "
6504 /*
6505 * In 9.6 and up, left join to pg_am to pick up the amname.
6506 */
6511 /*
6512 * We purposefully ignore toast OIDs for partitioned tables; the reason is
6513 * that versions 10 and 11 have them, but later versions do not, so
6514 * emitting them causes the upgrade to fail.
6515 */
6517 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
6521 /*
6522 * Restrict to interesting relkinds (in particular, not indexes). Not all
6523 * relkinds are possible in older servers, but it's not worth the trouble
6524 * to emit a version-dependent list.
6525 *
6526 * Composite-type table entries won't be dumped as such, but we have to
6527 * make a DumpableObject for them so that we can track dependencies of the
6528 * composite type (pg_depend entries for columns of the composite type
6529 * link to the pg_class entry not the pg_type entry).
6530 */
6532 "WHERE c.relkind IN ("
6548 /*
6549 * Extract data from result and lock dumpable tables. We do the locking
6550 * before anything else, to minimize the window wherein a table could
6551 * disappear under us.
6552 *
6553 * Note that we have to save info about all tables here, even when dumping
6554 * only one, because we don't yet know which tables might be inheritance
6555 * ancestors of the target table.
6556 */
6598 {
6599 /*
6600 * Arrange to fail instead of waiting forever for a table lock.
6601 *
6602 * NB: this coding assumes that the only queries issued within the
6603 * following loop are LOCK TABLEs; else the timeout may be undesirably
6604 * applied to other things too.
6605 */
6610 }
6615 {
6636 else
6639 {
6642 }
6643 else
6644 {
6647 }
6664 else
6671 else
6673 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
6676 /* other fields were zeroed above */
6678 /*
6679 * Decide whether we want to dump this table.
6680 */
6683 else
6686 /*
6687 * Now, consider the table "interesting" if we need to dump its
6688 * definition or its data. Later on, we'll skip a lot of data
6689 * collection for uninteresting tables.
6690 *
6691 * Note: the "interesting" flag will also be set by flagInhTables for
6692 * parents of interesting tables, so that we collect necessary
6693 * inheritance info even when the parents are not themselves being
6694 * dumped. This is the main reason why we need an "interesting" flag
6695 * that's separate from the components-to-dump bitmask.
6696 */
6704 /* Tables have data */
6707 /* Mark whether table has an ACL */
6712 /*
6713 * Read-lock target tables to make sure they aren't DROPPED or altered
6714 * in schema before we get around to dumping them.
6715 *
6716 * Note that we don't explicitly lock parents of the target tables; we
6717 * assume our lock on the child is enough to prevent schema
6718 * alterations to parent tables.
6719 *
6720 * NOTE: it'd be kinda nice to lock other relations too, not only
6721 * plain or partitioned tables, but the backend doesn't presently
6722 * allow that.
6723 *
6724 * We only need to lock the table for certain components; see
6725 * pg_dump.h
6726 */
6730 {
6731 /*
6732 * Tables are locked in batches. When dumping from a remote
6733 * server this can save a significant amount of time by reducing
6734 * the number of round trips.
6735 */
6739 else
6740 {
6744 /* Arbitrarily end a batch when query length reaches 100K. */
6746 {
6747 /* Lock another batch of tables. */
6751 }
6752 }
6753 }
6754 }
6757 {
6758 /* Lock the tables in the last batch. */
6761 }
6764 {
6766 }
6773 }
6775 /*
6776 * getOwnedSeqs
6777 * identify owned sequences and mark them as dumpable if owning table is
6778 *
6779 * We used to do this in getTables(), but it's better to do it after the
6780 * index used by findTableByOid() has been set up.
6781 */
6782 void
6784 {
6787 /*
6788 * Force sequences that are "owned" by table columns to be dumped whenever
6789 * their owning table is being dumped.
6790 */
6792 {
6804 /*
6805 * Only dump identity sequences if we're going to dump the table that
6806 * it belongs to.
6807 */
6810 {
6813 }
6815 /*
6816 * Otherwise we need to dump the components that are being dumped for
6817 * the table and any components which the sequence is explicitly
6818 * marked with.
6819 *
6820 * We can't simply use the set of components which are being dumped
6821 * for the table as the table might be in an extension (and only the
6822 * non-extension components, eg: ACLs if changed, security labels, and
6823 * policies, are being dumped) while the sequence is not (and
6824 * therefore the definition and other components should also be
6825 * dumped).
6826 *
6827 * If the sequence is part of the extension then it should be properly
6828 * marked by checkExtensionMembership() and this will be a no-op as
6829 * the table will be equivalently marked.
6830 */
6835 }
6836 }
6838 /*
6839 * getInherits
6840 * read all the inheritance information
6841 * from the system catalogs return them in the InhInfo* structure
6842 *
6843 * numInherits is set to the number of pairs read in
6844 */
6845 InhInfo *
6847 {
6857 /* find all the inheritance information */
6872 {
6875 }
6882 }
6884 /*
6885 * getPartitioningInfo
6886 * get information about partitioning
6887 *
6888 * For the most part, we only collect partitioning info about tables we
6889 * intend to dump. However, this function has to consider all partitioned
6890 * tables in the database, because we need to know about parents of partitions
6891 * we are going to dump even if the parents themselves won't be dumped.
6892 *
6893 * Specifically, what we need to know is whether each partitioned table
6894 * has an "unsafe" partitioning scheme that requires us to force
6895 * load-via-partition-root mode for its children. Currently the only case
6896 * for which we force that is hash partitioning on enum columns, since the
6897 * hash codes depend on enum value OIDs which won't be replicated across
6898 * dump-and-reload. There are other cases in which load-via-partition-root
6899 * might be necessary, but we expect users to cope with them.
6900 */
6901 void
6903 {
6904 PQExpBuffer query;
6908 /* hash partitioning didn't exist before v11 */
6911 /* needn't bother if schema-only dump */
6917 /*
6918 * Unsafe partitioning schemes are exactly those for which hash enum_ops
6919 * appears among the partition opclasses. We needn't check partstrat.
6920 *
6921 * Note that this query may well retrieve info about tables we aren't
6922 * going to dump and hence have no lock on. That's okay since we need not
6923 * invoke any unsafe server-side functions.
6924 */
6927 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
6929 "WHERE opcname = 'enum_ops' "
6930 "AND opcnamespace = 'pg_catalog'::regnamespace "
6938 {
6945 tabrelid);
6947 }
6952 }
6954 /*
6955 * getIndexes
6956 * get information about every index on a dumpable table
6957 *
6958 * Note: index data is not returned directly to the caller, but it
6959 * does get entered into the DumpableObject tables.
6960 */
6961 void
6963 {
6971 i_oid,
6972 i_indrelid,
6973 i_indexname,
6974 i_parentidx,
6975 i_indexdef,
6976 i_indnkeyatts,
6977 i_indnatts,
6978 i_indkey,
6979 i_indisclustered,
6980 i_indisreplident,
6981 i_indnullsnotdistinct,
6982 i_contype,
6983 i_conname,
6984 i_condeferrable,
6985 i_condeferred,
6986 i_contableoid,
6987 i_conoid,
6988 i_condef,
6989 i_tablespace,
6990 i_indreloptions,
6991 i_indstatcols,
6992 i_indstatvals;
6994 /*
6995 * We want to perform just one query against pg_index. However, we
6996 * mustn't try to select every row of the catalog and then sort it out on
6997 * the client side, because some of the server-side functions we need
6998 * would be unsafe to apply to tables we don't have lock on. Hence, we
6999 * build an array of the OIDs of tables we care about (and now have lock
7000 * on!), and use a WHERE clause to constrain which rows are selected.
7001 */
7004 {
7010 /*
7011 * We can ignore indexes of uninteresting tables.
7012 */
7016 /* OK, we need info for this table */
7020 }
7024 "SELECT t.tableoid, t.oid, i.indrelid, "
7025 "t.relname AS indexname, "
7026 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7027 "i.indkey, i.indisclustered, "
7028 "c.contype, c.conname, "
7029 "c.condeferrable, c.condeferred, "
7030 "c.tableoid AS contableoid, "
7031 "c.oid AS conoid, "
7032 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7033 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7040 else
7046 "inh.inhparent AS parentidx, "
7047 "i.indnkeyatts AS indnkeyatts, "
7048 "i.indnatts AS indnatts, "
7049 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7050 " FROM pg_catalog.pg_attribute "
7051 " WHERE attrelid = i.indexrelid AND "
7052 " attstattarget >= 0) AS indstatcols, "
7053 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7054 " FROM pg_catalog.pg_attribute "
7055 " WHERE attrelid = i.indexrelid AND "
7057 else
7059 "0 AS parentidx, "
7060 "i.indnatts AS indnkeyatts, "
7061 "i.indnatts AS indnatts, "
7062 "'' AS indstatcols, "
7068 else
7072 /*
7073 * The point of the messy-looking outer join is to find a constraint that
7074 * is related by an internal dependency link to the index. If we find one,
7075 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
7076 * index won't have more than one internal dependency.
7077 *
7078 * Note: the check on conrelid is redundant, but useful because that
7079 * column is indexed while conindid is not.
7080 */
7082 {
7085 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7086 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7087 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
7088 "LEFT JOIN pg_catalog.pg_constraint c "
7089 "ON (i.indrelid = c.conrelid AND "
7090 "i.indexrelid = c.conindid AND "
7091 "c.contype IN ('p','u','x')) "
7092 "LEFT JOIN pg_catalog.pg_inherits inh "
7093 "ON (inh.inhrelid = indexrelid) "
7094 "WHERE (i.indisvalid OR t2.relkind = 'p') "
7095 "AND i.indisready "
7098 }
7099 else
7100 {
7101 /*
7102 * the test on indisready is necessary in 9.2, and harmless in
7103 * earlier/later versions
7104 */
7107 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7108 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7109 "LEFT JOIN pg_catalog.pg_constraint c "
7110 "ON (i.indrelid = c.conrelid AND "
7111 "i.indexrelid = c.conindid AND "
7112 "c.contype IN ('p','u','x')) "
7113 "WHERE i.indisvalid AND i.indisready "
7116 }
7148 /*
7149 * Outer loop iterates once per table, not once per row. Incrementing of
7150 * j is handled by the inner loop.
7151 */
7154 {
7159 /* Count rows for this table */
7164 /*
7165 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
7166 * order.
7167 */
7169 {
7173 }
7176 /* cross-check that we only got requested tables */
7182 /* Save data for this table */
7187 {
7213 {
7214 NULL, NULL
7215 };
7219 {
7220 /*
7221 * If we found a constraint matching the index, create an
7222 * entry for it.
7223 */
7239 else
7249 }
7250 else
7251 {
7252 /* Plain secondary index */
7254 }
7255 }
7256 }
7262 }
7264 /*
7265 * getExtendedStatistics
7266 * get information about extended-statistics objects.
7267 *
7268 * Note: extended statistics data is not returned directly to the caller, but
7269 * it does get entered into the DumpableObject tables.
7270 */
7271 void
7273 {
7274 PQExpBuffer query;
7286 /* Extended statistics were new in v10 */
7294 "stxnamespace, stxowner, (-1) AS stxstattarget "
7296 else
7298 "stxnamespace, stxowner, stxstattarget "
7315 {
7326 /* Decide whether we want to dump it */
7328 }
7332 }
7334 /*
7335 * getConstraints
7336 *
7337 * Get info about constraints on dumpable tables.
7338 *
7339 * Currently handles foreign keys only.
7340 * Unique and primary key constraints are handled with indexes,
7341 * while check constraints are processed in getTableAttrs().
7342 */
7343 void
7345 {
7354 i_conoid,
7355 i_conrelid,
7356 i_conname,
7357 i_confrelid,
7358 i_conindid,
7359 i_condef;
7361 /*
7362 * We want to perform just one query against pg_constraint. However, we
7363 * mustn't try to select every row of the catalog and then sort it out on
7364 * the client side, because some of the server-side functions we need
7365 * would be unsafe to apply to tables we don't have lock on. Hence, we
7366 * build an array of the OIDs of tables we care about (and now have lock
7367 * on!), and use a WHERE clause to constrain which rows are selected.
7368 */
7371 {
7374 /*
7375 * For partitioned tables, foreign keys have no triggers so they must
7376 * be included anyway in case some foreign keys are defined.
7377 */
7383 /* OK, we need info for this table */
7387 }
7391 "SELECT c.tableoid, c.oid, "
7395 else
7425 {
7429 /*
7430 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
7431 * order.
7432 */
7434 {
7436 {
7440 }
7443 }
7462 /*
7463 * Restoring an FK that points to a partitioned table requires that
7464 * all partition indexes have been attached beforehand. Ensure that
7465 * happens by making the constraint depend on each index partition
7466 * attach object.
7467 */
7470 {
7474 {
7476 {
7479 /* not our index? */
7486 }
7487 }
7488 }
7489 }
7495 }
7497 /*
7498 * addConstrChildIdxDeps
7499 *
7500 * Recursive subroutine for getConstraints
7501 *
7502 * Given an object representing a foreign key constraint and an index on the
7503 * partitioned table it references, mark the constraint object as dependent
7504 * on the DO_INDEX_ATTACH object of each index partition, recursively
7505 * drilling down to their partitions if any. This ensures that the FK is not
7506 * restored until the index is fully marked valid.
7507 */
7508 static void
7510 {
7516 {
7523 }
7524 }
7526 /*
7527 * getDomainConstraints
7528 *
7529 * Get info about constraints on a domain.
7530 */
7531 static void
7533 {
7539 i_oid,
7540 i_conname,
7541 i_consrc;
7545 {
7546 /* Set up query for constraint-specific details */
7549 "SELECT tableoid, oid, conname, "
7550 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
7551 "convalidated "
7552 "FROM pg_catalog.pg_constraint "
7553 "WHERE contypid = $1 "
7559 }
7580 {
7601 /*
7602 * Make the domain depend on the constraint, ensuring it won't be
7603 * output till any constraint dependencies are OK. If the constraint
7604 * has not been validated, it's going to be dumped after the domain
7605 * anyway, so this doesn't matter.
7606 */
7610 }
7615 }
7617 /*
7618 * getRules
7619 * get basic information about every rule in the system
7620 *
7621 * numRules is set to the number of rules read in
7622 */
7623 RuleInfo *
7625 {
7640 "tableoid, oid, rulename, "
7641 "ev_class AS ruletable, ev_type, is_instead, "
7642 "ev_enabled "
7643 "FROM pg_rewrite "
7663 {
7664 Oid ruletableoid;
7674 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
7682 {
7683 /*
7684 * If the table is a view or materialized view, force its ON
7685 * SELECT rule to be sorted before the view itself --- this
7686 * ensures that any dependencies for the rule affect the table's
7687 * positioning. Other rules are forced to appear after their
7688 * table.
7689 */
7693 {
7696 /* We'll merge the rule into CREATE VIEW, if possible */
7698 }
7699 else
7700 {
7704 }
7705 }
7706 else
7708 }
7715 }
7717 /*
7718 * getTriggers
7719 * get information about every trigger on a dumpable table
7720 *
7721 * Note: trigger data is not returned directly to the caller, but it
7722 * does get entered into the DumpableObject tables.
7723 */
7724 void
7726 {
7734 i_oid,
7735 i_tgrelid,
7736 i_tgname,
7737 i_tgfname,
7738 i_tgtype,
7739 i_tgnargs,
7740 i_tgargs,
7741 i_tgisconstraint,
7742 i_tgconstrname,
7743 i_tgconstrrelid,
7744 i_tgconstrrelname,
7745 i_tgenabled,
7746 i_tgispartition,
7747 i_tgdeferrable,
7748 i_tginitdeferred,
7749 i_tgdef;
7751 /*
7752 * We want to perform just one query against pg_trigger. However, we
7753 * mustn't try to select every row of the catalog and then sort it out on
7754 * the client side, because some of the server-side functions we need
7755 * would be unsafe to apply to tables we don't have lock on. Hence, we
7756 * build an array of the OIDs of tables we care about (and now have lock
7757 * on!), and use a WHERE clause to constrain which rows are selected.
7758 */
7761 {
7768 /* OK, we need info for this table */
7772 }
7776 {
7777 /*
7778 * NB: think not to use pretty=true in pg_get_triggerdef. It could
7779 * result in non-forward-compatible dumps of WHEN clauses due to
7780 * under-parenthesization.
7781 *
7782 * NB: We need to see partition triggers in case the tgenabled flag
7783 * has been changed from the parent.
7784 */
7786 "SELECT t.tgrelid, t.tgname, "
7787 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7788 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7789 "t.tgenabled, t.tableoid, t.oid, "
7792 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
7793 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
7794 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
7795 "OR t.tgenabled != u.tgenabled) "
7798 }
7800 {
7801 /*
7802 * NB: think not to use pretty=true in pg_get_triggerdef. It could
7803 * result in non-forward-compatible dumps of WHEN clauses due to
7804 * under-parenthesization.
7805 *
7806 * NB: We need to see tgisinternal triggers in partitions, in case the
7807 * tgenabled flag has been changed from the parent.
7808 */
7810 "SELECT t.tgrelid, t.tgname, "
7811 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7812 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7815 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
7816 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
7817 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
7820 }
7822 {
7823 /*
7824 * NB: We need to see tgisinternal triggers in partitions, in case the
7825 * tgenabled flag has been changed from the parent. No tgparentid in
7826 * version 11-12, so we have to match them via pg_depend.
7827 *
7828 * See above about pretty=true in pg_get_triggerdef.
7829 */
7831 "SELECT t.tgrelid, t.tgname, "
7832 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7833 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7834 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
7836 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
7837 "LEFT JOIN pg_catalog.pg_depend AS d ON "
7838 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
7839 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
7840 " d.objid = t.oid "
7841 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
7842 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
7845 }
7846 else
7847 {
7848 /* See above about pretty=true in pg_get_triggerdef */
7850 "SELECT t.tgrelid, t.tgname, "
7851 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7852 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7853 "t.tgenabled, false as tgispartition, "
7854 "t.tableoid, t.oid "
7856 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
7857 "WHERE NOT tgisinternal "
7860 }
7886 /*
7887 * Outer loop iterates once per table, not once per row. Incrementing of
7888 * j is handled by the inner loop.
7889 */
7892 {
7897 /* Count rows for this table */
7902 /*
7903 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
7904 * order.
7905 */
7907 {
7911 }
7915 /* Save data for this table */
7920 {
7931 {
7934 /* remaining fields are not valid if we have tgdef */
7945 }
7946 else
7947 {
7959 {
7963 {
7965 pg_fatal("query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)",
7970 }
7971 else
7973 }
7974 else
7975 {
7979 }
7980 }
7981 }
7982 }
7988 }
7990 /*
7991 * getEventTriggers
7992 * get information about event triggers
7993 */
7994 EventTriggerInfo *
7996 {
7998 PQExpBuffer query;
8002 i_oid,
8003 i_evtname,
8004 i_evtevent,
8005 i_evtowner,
8006 i_evttags,
8007 i_evtfname,
8008 i_evtenabled;
8011 /* Before 9.3, there are no event triggers */
8013 {
8016 }
8021 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8022 "evtevent, evtowner, "
8023 "array_to_string(array("
8024 "select quote_literal(x) "
8025 " from unnest(evttags) as t(x)), ', ') as evttags, "
8026 "e.evtfoid::regproc as evtfname "
8027 "FROM pg_event_trigger e "
8048 {
8061 /* Decide whether we want to dump it */
8063 }
8070 }
8072 /*
8073 * getProcLangs
8074 * get basic information about every procedural language in the system
8075 *
8076 * numProcLangs is set to the number of langs read in
8077 *
8078 * NB: this must run after getFuncs() because we assume we can do
8079 * findFuncByOid().
8080 */
8081 ProcLangInfo *
8083 {
8101 "lanname, lanpltrusted, lanplcallfoid, "
8102 "laninline, lanvalidator, "
8103 "lanacl, "
8104 "acldefault('l', lanowner) AS acldefault, "
8105 "lanowner "
8106 "FROM pg_language "
8107 "WHERE lanispl "
8130 {
8147 /* Decide whether we want to dump it */
8150 /* Mark whether language has an ACL */
8153 }
8160 }
8162 /*
8163 * getCasts
8164 * get basic information about most casts in the system
8165 *
8166 * numCasts is set to the number of casts read in
8167 *
8168 * Skip casts from a range to its multirange, since we'll create those
8169 * automatically.
8170 */
8171 CastInfo *
8173 {
8188 {
8190 "castsource, casttarget, castfunc, castcontext, "
8191 "castmethod "
8192 "FROM pg_cast c "
8193 "WHERE NOT EXISTS ( "
8194 "SELECT 1 FROM pg_range r "
8195 "WHERE c.castsource = r.rngtypid "
8196 "AND c.casttarget = r.rngmultitypid "
8197 ") "
8199 }
8200 else
8201 {
8203 "castsource, casttarget, castfunc, castcontext, "
8204 "castmethod "
8206 }
8225 {
8226 PQExpBufferData namebuf;
8240 /*
8241 * Try to name cast as concatenation of typnames. This is only used
8242 * for purposes of sorting. If we fail to find either type, the name
8243 * will be an empty string.
8244 */
8253 /* Decide whether we want to dump it */
8255 }
8262 }
8266 {
8267 PQExpBuffer query;
8279 }
8281 /*
8282 * getTransforms
8283 * get basic information about every transform in the system
8284 *
8285 * numTransforms is set to the number of transforms read in
8286 */
8287 TransformInfo *
8289 {
8293 PQExpBuffer query;
8302 /* Transforms didn't exist pre-9.5 */
8304 {
8307 }
8312 "trftype, trflang, trffromsql::oid, trftosql::oid "
8313 "FROM pg_transform "
8332 {
8333 PQExpBufferData namebuf;
8346 /*
8347 * Try to name transform as concatenation of type and language name.
8348 * This is only used for purposes of sorting. If we fail to find
8349 * either, the name will be an empty string.
8350 */
8360 /* Decide whether we want to dump it */
8362 }
8369 }
8371 /*
8372 * getTableAttrs -
8373 * for each interesting table, read info about its attributes
8374 * (names, types, default values, CHECK constraints, etc)
8375 *
8376 * modifies tblinfo
8377 */
8378 void
8380 {
8412 /*
8413 * We want to perform just one query against pg_attribute, and then just
8414 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
8415 * (for CHECK constraints and for NOT NULL constraints). However, we
8416 * mustn't try to select every row of those catalogs and then sort it out
8417 * on the client side, because some of the server-side functions we need
8418 * would be unsafe to apply to tables we don't have lock on. Hence, we
8419 * build an array of the OIDs of tables we care about (and now have lock
8420 * on!), and use a WHERE clause to constrain which rows are selected.
8421 */
8425 {
8428 /* Don't bother to collect info for sequences */
8432 /* Don't bother with uninteresting tables, either */
8436 /* OK, we need info for this table */
8442 {
8443 /* Also make a list of the ones with check constraints */
8447 }
8448 }
8452 /*
8453 * Find all the user attributes and their types.
8454 *
8455 * Since we only want to dump COLLATE clauses for attributes whose
8456 * collation is different from their type's default, we use a CASE here to
8457 * suppress uninteresting attcollations cheaply.
8458 */
8474 "CASE WHEN a.attcollation <> t.typcollation "
8476 "pg_catalog.array_to_string(ARRAY("
8477 "SELECT pg_catalog.quote_ident(option_name) || "
8478 "' ' || pg_catalog.quote_literal(option_value) "
8479 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
8480 "ORDER BY option_name"
8483 /*
8484 * Find out any NOT NULL markings for each column. In 17 and up we have
8485 * to read pg_constraint, and keep track whether it's NO INHERIT; in older
8486 * versions we rely on pg_attribute.attnotnull.
8487 *
8488 * We also track whether the constraint was defined directly in this table
8489 * or via an ancestor, for binary upgrade.
8490 *
8491 * Lastly, we need to know if the PK for the table involves each column;
8492 * for columns that are there we need a NOT NULL marking even if there's
8493 * no explicit constraint, to avoid the table having to be scanned for
8494 * NULLs after the data is loaded when the PK is created, later in the
8495 * dump; for this case we add throwaway constraints that are dropped once
8496 * the PK is created.
8497 */
8504 else
8514 else
8521 else
8527 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
8529 else
8536 else
8540 /* need left join to pg_type to not fail on dropped columns ... */
8543 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
8544 "LEFT JOIN pg_catalog.pg_type t "
8548 /*
8549 * In versions 16 and up, we need pg_constraint for explicit NOT NULL
8550 * entries. Also, we need to know if the NOT NULL for each column is
8551 * backing a primary key.
8552 */
8555 " LEFT JOIN pg_catalog.pg_constraint co ON "
8557 " AND co.contype = 'n' AND "
8561 "LEFT JOIN pg_catalog.pg_constraint copk ON "
8563 " AND copk.contype = 'p' AND "
8596 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
8600 /*
8601 * Outer loop iterates once per table, not once per row. Incrementing of
8602 * r is handled by the inner loop.
8603 */
8606 {
8613 /* Count rows for this table */
8618 /*
8619 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8620 * order.
8621 */
8623 {
8627 }
8630 /* cross-check that we only got requested tables */
8638 /* Save data for this table */
8664 {
8679 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
8685 /*
8686 * Not-null constraints require a jumping through a few hoops.
8687 * First, if the user has specified a constraint name that's not
8688 * the system-assigned default name, then we need to preserve
8689 * that. But if they haven't, then we don't want to use the
8690 * verbose syntax in the dump output. (Also, in versions prior to
8691 * 17, there was no constraint name at all.)
8692 *
8693 * (XXX Comparing the name this way to a supposed default name is
8694 * a bit of a hack, but it beats having to store a boolean flag in
8695 * pg_constraint just for this, or having to compute the knowledge
8696 * at pg_dump time from the server.)
8697 *
8698 * We also need to know if a column is part of the primary key. In
8699 * that case, we want to mark the column as not-null at table
8700 * creation time, so that the table doesn't have to be scanned to
8701 * check for nulls when the PK is created afterwards; this is
8702 * especially critical during pg_upgrade (where the data would not
8703 * be scanned at all otherwise.) If the column is part of the PK
8704 * and does not have any other not-null constraint, then we
8705 * fabricate a throwaway constraint name that we later use to
8706 * remove the constraint after the PK has been created.
8707 *
8708 * For inheritance child tables, we don't want to print not-null
8709 * when the constraint was defined at the parent level instead of
8710 * locally.
8711 */
8713 /*
8714 * We use notnull_inh to suppress unwanted not-null constraints in
8715 * inheritance children, when said constraints come from the
8716 * parent(s).
8717 */
8721 {
8726 {
8728 /* XXX should match ChooseConstraintName better */
8732 }
8737 }
8738 else
8739 {
8741 {
8742 /*
8743 * In binary upgrade of inheritance child tables, must
8744 * have a constraint name that we can UPDATE later.
8745 */
8749 {
8754 }
8755 else
8756 {
8759 /* XXX should match ChooseConstraintName better */
8765 else
8766 {
8770 }
8771 }
8772 }
8775 }
8778 {
8781 }
8783 {
8784 /* The name itself has already been determined */
8786 }
8788 {
8793 }
8794 else
8795 {
8798 }
8800 /*
8801 * Throwaway constraints must always be NO INHERIT; otherwise do
8802 * what the catalog says.
8803 */
8815 }
8818 {
8819 /* Collect OIDs of interesting tables that have defaults */
8823 }
8824 }
8828 /*
8829 * Now get info about column defaults. This is skipped for a data-only
8830 * dump, as it is only needed for table schemas.
8831 */
8833 {
8856 {
8863 /*
8864 * Locate the associated TableInfo; we rely on tblinfo[] being in
8865 * OID order.
8866 */
8868 {
8870 {
8874 }
8877 }
8883 /*
8884 * dropped columns shouldn't have defaults, but just in case,
8885 * ignore 'em
8886 */
8903 /*
8904 * Figure out whether the default/generation expression should be
8905 * dumped as part of the main CREATE TABLE (or similar) command or
8906 * as a separate ALTER TABLE (or similar) command. The preference
8907 * is to put it into the CREATE command, but in some cases that's
8908 * not possible.
8909 */
8911 {
8912 /*
8913 * Column generation expressions cannot be dumped separately,
8914 * because there is no syntax for it. By setting separate to
8915 * false here we prevent the "default" from being processed as
8916 * its own dumpable object. Later, flagInhAttrs() will mark
8917 * it as not to be dumped at all, if possible (that is, if it
8918 * can be inherited from a parent).
8919 */
8921 }
8923 {
8924 /*
8925 * Defaults on a VIEW must always be dumped as separate ALTER
8926 * TABLE commands.
8927 */
8929 }
8931 {
8932 /* column will be suppressed, print default separately */
8934 }
8935 else
8936 {
8938 }
8941 {
8942 /*
8943 * Mark the default as needing to appear before the table, so
8944 * that any dependencies it has must be emitted before the
8945 * CREATE TABLE. If this is not possible, we'll change to
8946 * "separate" mode while sorting dependencies.
8947 */
8950 }
8953 }
8956 }
8958 /*
8959 * Get info about table CHECK constraints. This is skipped for a
8960 * data-only dump, as it is only needed for table schemas.
8961 */
8963 {
8978 "SELECT c.tableoid, c.oid, conrelid, conname, "
8979 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
8980 "conislocal, convalidated "
8983 "WHERE contype = 'c' "
9000 /* As above, this loop iterates once per table, not once per row */
9003 {
9008 /* Count rows for this table */
9013 /*
9014 * Locate the associated TableInfo; we rely on tblinfo[] being in
9015 * OID order.
9016 */
9018 {
9022 }
9027 {
9034 }
9039 {
9058 /*
9059 * An unvalidated constraint needs to be dumped separately, so
9060 * that potentially-violating existing data is loaded before
9061 * the constraint.
9062 */
9067 /*
9068 * Mark the constraint as needing to appear before the table
9069 * --- this is so that any other dependencies of the
9070 * constraint will be emitted before we try to create the
9071 * table. If the constraint is to be dumped separately, it
9072 * will be dumped after data is loaded anyway, so don't do it.
9073 * (There's an automatic dependency in the opposite direction
9074 * anyway, so don't need to add one manually here.)
9075 */
9080 /*
9081 * We will detect later whether the constraint must be split
9082 * out from the table definition.
9083 */
9084 }
9085 }
9088 }
9093 }
9095 /*
9096 * Test whether a column should be printed as part of table's CREATE TABLE.
9097 * Column number is zero-based.
9098 *
9099 * Normally this is always true, but it's false for dropped columns, as well
9100 * as those that were inherited without any local definition. (If we print
9101 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
9102 * For partitions, it's always true, because we want the partitions to be
9103 * created independently and ATTACH PARTITION used afterwards.
9104 *
9105 * In binary_upgrade mode, we must print all columns and fix the attislocal/
9106 * attisdropped state later, so as to keep control of the physical column
9107 * order.
9108 *
9109 * This function exists because there are scattered nonobvious places that
9110 * must be kept in sync with this decision.
9111 */
9112 bool
9114 {
9120 }
9123 /*
9124 * getTSParsers:
9125 * read all text search parsers in the system catalogs and return them
9126 * in the TSParserInfo* structure
9127 *
9128 * numTSParsers is set to the number of parsers read in
9129 */
9130 TSParserInfo *
9132 {
9136 PQExpBuffer query;
9150 /*
9151 * find all text search objects, including builtin ones; we filter out
9152 * system-defined objects at dump-out time.
9153 */
9156 "prsstart::oid, prstoken::oid, "
9157 "prsend::oid, prsheadline::oid, prslextype::oid "
9178 {
9192 /* Decide whether we want to dump it */
9194 }
9201 }
9203 /*
9204 * getTSDictionaries:
9205 * read all text search dictionaries in the system catalogs and return them
9206 * in the TSDictInfo* structure
9207 *
9208 * numTSDicts is set to the number of dictionaries read in
9209 */
9210 TSDictInfo *
9212 {
9216 PQExpBuffer query;
9229 "dictnamespace, dictowner, "
9230 "dicttemplate, dictinitoption "
9249 {
9261 else
9264 /* Decide whether we want to dump it */
9266 }
9273 }
9275 /*
9276 * getTSTemplates:
9277 * read all text search templates in the system catalogs and return them
9278 * in the TSTemplateInfo* structure
9279 *
9280 * numTSTemplates is set to the number of templates read in
9281 */
9282 TSTemplateInfo *
9284 {
9288 PQExpBuffer query;
9300 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
9318 {
9329 /* Decide whether we want to dump it */
9331 }
9338 }
9340 /*
9341 * getTSConfigurations:
9342 * read all text search configurations in the system catalogs and return
9343 * them in the TSConfigInfo* structure
9344 *
9345 * numTSConfigs is set to the number of configurations read in
9346 */
9347 TSConfigInfo *
9349 {
9353 PQExpBuffer query;
9365 "cfgnamespace, cfgowner, cfgparser "
9383 {
9394 /* Decide whether we want to dump it */
9396 }
9403 }
9405 /*
9406 * getForeignDataWrappers:
9407 * read all foreign-data wrappers in the system catalogs and return
9408 * them in the FdwInfo* structure
9409 *
9410 * numForeignDataWrappers is set to the number of fdws read in
9411 */
9412 FdwInfo *
9414 {
9418 PQExpBuffer query;
9433 "fdwowner, "
9434 "fdwhandler::pg_catalog.regproc, "
9435 "fdwvalidator::pg_catalog.regproc, "
9436 "fdwacl, "
9437 "acldefault('F', fdwowner) AS acldefault, "
9438 "array_to_string(ARRAY("
9439 "SELECT quote_ident(option_name) || ' ' || "
9440 "quote_literal(option_value) "
9441 "FROM pg_options_to_table(fdwoptions) "
9442 "ORDER BY option_name"
9464 {
9480 /* Decide whether we want to dump it */
9483 /* Mark whether FDW has an ACL */
9486 }
9493 }
9495 /*
9496 * getForeignServers:
9497 * read all foreign servers in the system catalogs and return
9498 * them in the ForeignServerInfo * structure
9499 *
9500 * numForeignServers is set to the number of servers read in
9501 */
9502 ForeignServerInfo *
9504 {
9508 PQExpBuffer query;
9524 "srvowner, "
9525 "srvfdw, srvtype, srvversion, srvacl, "
9526 "acldefault('S', srvowner) AS acldefault, "
9527 "array_to_string(ARRAY("
9528 "SELECT quote_ident(option_name) || ' ' || "
9529 "quote_literal(option_value) "
9530 "FROM pg_options_to_table(srvoptions) "
9531 "ORDER BY option_name"
9554 {
9571 /* Decide whether we want to dump it */
9574 /* Servers have user mappings */
9577 /* Mark whether server has an ACL */
9580 }
9587 }
9589 /*
9590 * getDefaultACLs:
9591 * read all default ACL information in the system catalogs and return
9592 * them in the DefaultACLInfo structure
9593 *
9594 * numDefaultACLs is set to the number of ACLs read in
9595 */
9596 DefaultACLInfo *
9598 {
9601 PQExpBuffer query;
9611 ntups;
9615 /*
9616 * Global entries (with defaclnamespace=0) replace the hard-wired default
9617 * ACL for their object type. We should dump them as deltas from the
9618 * default ACL, since that will be used as a starting point for
9619 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
9620 * non-global entries can only add privileges not revoke them. We must
9621 * dump those as-is (i.e., as deltas from an empty ACL).
9622 *
9623 * We can use defaclobjtype as the object type for acldefault(), except
9624 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
9625 * 's'.
9626 */
9628 "SELECT oid, tableoid, "
9629 "defaclrole, "
9630 "defaclnamespace, "
9631 "defaclobjtype, "
9632 "defaclacl, "
9633 "CASE WHEN defaclnamespace = 0 THEN "
9634 "acldefault(CASE WHEN defaclobjtype = 'S' "
9636 "defaclrole) ELSE '{}' END AS acldefault "
9655 {
9662 /* cheesy ... is it worth coming up with a better object name? */
9667 else
9677 /* Default ACLs are ACLs, of course */
9680 /* Decide whether we want to dump it */
9682 }
9689 }
9691 /*
9692 * getRoleName -- look up the name of a role, given its OID
9693 *
9694 * In current usage, we don't expect failures, so error out for a bad OID.
9695 */
9698 {
9701 /*
9702 * Do binary search to find the appropriate item.
9703 */
9705 {
9710 {
9717 else
9719 }
9720 }
9724 }
9726 /*
9727 * collectRoleNames --
9728 *
9729 * Construct a table of all known roles.
9730 * The table is sorted by OID for speed in lookup.
9731 */
9732 static void
9734 {
9748 {
9751 }
9754 }
9756 /*
9757 * getAdditionalACLs
9758 *
9759 * We have now created all the DumpableObjects, and collected the ACL data
9760 * that appears in the directly-associated catalog entries. However, there's
9761 * more ACL-related info to collect. If any of a table's columns have ACLs,
9762 * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
9763 * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
9764 * Also, in versions having the pg_init_privs catalog, read that and load the
9765 * information into the relevant DumpableObjects.
9766 */
9767 static void
9769 {
9773 i;
9775 /* Check for per-column ACLs */
9777 "SELECT DISTINCT attrelid FROM pg_attribute "
9784 {
9789 /* OK to ignore tables we haven't got a DumpableObject for */
9791 {
9794 }
9795 }
9798 /* Fetch initial-privileges data */
9800 {
9802 "SELECT objoid, classoid, objsubid, privtype, initprivs "
9809 {
9815 CatalogId objId;
9821 /* OK to ignore entries we haven't got a DumpableObject for */
9823 {
9824 /* Cope with sub-object initprivs */
9826 {
9828 {
9829 /* For a column initprivs, set the table's ACL flags */
9832 }
9833 else
9837 }
9839 /*
9840 * We ignore any pg_init_privs.initprivs entry for the public
9841 * schema, as explained in getNamespaces().
9842 */
9847 /* Else it had better be of a type we think has ACLs */
9856 {
9861 }
9862 else
9865 }
9866 }
9868 }
9871 }
9873 /*
9874 * dumpCommentExtended --
9875 *
9876 * This routine is used to dump any comments associated with the
9877 * object handed to this routine. The routine takes the object type
9878 * and object name (ready to print, except for schema decoration), plus
9879 * the namespace and owner of the object (for labeling the ArchiveEntry),
9880 * plus catalog ID and subid which are the lookup key for pg_description,
9881 * plus the dump ID for the object (for setting a dependency).
9882 * If a matching pg_description entry is found, it is dumped.
9883 *
9884 * Note: in some cases, such as comments for triggers and rules, the "type"
9885 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
9886 * but it doesn't seem worth complicating the API for all callers to make
9887 * it cleaner.
9888 *
9889 * Note: although this routine takes a dumpId for dependency purposes,
9890 * that purpose is just to mark the dependency in the emitted dump file
9891 * for possible future use by pg_restore. We do NOT use it for determining
9892 * ordering of the comment in the dump file, because this routine is called
9893 * after dependency sorting occurs. This routine should be called just after
9894 * calling ArchiveEntry() for the specified object.
9895 */
9896 static void
9902 {
9907 /* do nothing, if --no-comments is supplied */
9911 /* Comments are schema not data ... except LO comments are data */
9913 {
9916 }
9917 else
9918 {
9919 /* We do dump LO comments in binary-upgrade mode */
9922 }
9924 /* Search for comments associated with catalogId, using table */
9928 /* Is there one matching the subid? */
9930 {
9933 comments++;
9934 ncomments--;
9935 }
9938 {
9941 /*
9942 * initdb creates this object with a comment. Skip dumping the
9943 * initdb-provided comment, which would complicate matters for
9944 * non-superuser use of pg_dump. When the DBA has removed initdb's
9945 * comment, replicate that.
9946 */
9948 {
9951 }
9954 }
9956 /* If a comment exists, build COMMENT ON statement */
9958 {
9971 /*
9972 * We mark comments as SECTION_NONE because they really belong in the
9973 * same section as their parent, whether that is pre-data or
9974 * post-data.
9975 */
9988 }
9989 }
9991 /*
9992 * dumpComment --
9993 *
9994 * Typical simplification of the above function.
9995 */
10001 {
10004 }
10006 /*
10007 * dumpTableComment --
10008 *
10009 * As above, but dump comments for both the specified table (or view)
10010 * and its columns.
10011 */
10012 static void
10015 {
10019 PQExpBuffer query;
10020 PQExpBuffer tag;
10022 /* do nothing, if --no-comments is supplied */
10026 /* Comments are SCHEMA not data */
10030 /* Search for comments associated with relation, using table */
10035 /* If comments exist, build COMMENT ON statements */
10043 {
10048 {
10068 }
10070 {
10093 }
10095 comments++;
10096 ncomments--;
10097 }
10101 }
10103 /*
10104 * findComments --
10105 *
10106 * Find the comment(s), if any, associated with the given object. All the
10107 * objsubid values associated with the given classoid/objoid are found with
10108 * one search.
10109 */
10110 static int
10112 {
10118 /*
10119 * Do binary search to find some item matching the object.
10120 */
10124 {
10135 else
10137 }
10140 {
10143 }
10145 /*
10146 * Now determine how many items match the object. The search loop
10147 * invariant still holds: only items between low and high inclusive could
10148 * match.
10149 */
10152 {
10156 middle--;
10157 nmatch++;
10158 }
10164 {
10168 middle++;
10169 nmatch++;
10170 }
10173 }
10175 /*
10176 * collectComments --
10177 *
10178 * Construct a table of all comments available for database objects;
10179 * also set the has-comment component flag for each relevant object.
10180 *
10181 * We used to do per-object queries for the comments, but it's much faster
10182 * to pull them all over at once, and on most databases the memory cost
10183 * isn't high.
10184 *
10185 * The table is sorted by classoid/objid/objsubid for speed in lookup.
10186 */
10187 static void
10189 {
10191 PQExpBuffer query;
10203 "FROM pg_catalog.pg_description "
10208 /* Construct lookup table containing OIDs in numeric form */
10222 {
10223 CatalogId objId;
10230 /* We needn't remember comments that don't match any dumpable object */
10238 /*
10239 * Comments on columns of composite types are linked to the type's
10240 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
10241 * in the type's own DumpableObject.
10242 */
10245 {
10251 }
10252 else
10259 ncomments++;
10260 }
10264 }
10266 /*
10267 * dumpDumpableObject
10268 *
10269 * This routine and its subsidiaries are responsible for creating
10270 * ArchiveEntries (TOC objects) for each object to be dumped.
10271 */
10272 static void
10274 {
10275 /*
10276 * Clear any dump-request bits for components that don't exist for this
10277 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
10278 * request for every kind of object.)
10279 */
10282 /* Now, short-circuit if there's nothing to be done here. */
10287 {
10376 /* table rowtypes and array types are never dumped separately */
10404 {
10413 /*
10414 * Set the TocEntry's dataLength in case we are doing a
10415 * parallel dump and want to order dump jobs by table size.
10416 * (We need some size estimate for every TocEntry with a
10417 * DataDumper function.) We don't currently have any cheap
10418 * way to estimate the size of LOs, but it doesn't matter;
10419 * let's just set the size to a large value so parallel dumps
10420 * will launch this job first. If there's lots of LOs, we
10421 * win, and if there aren't, we don't lose much. (If you want
10422 * to improve on this, really what you should be thinking
10423 * about is allowing LO dumping to be parallelized, not just
10424 * getting a smarter estimate for the single TOC entry.)
10425 */
10427 }
10447 /* never dumped, nothing to do */
10449 }
10450 }
10452 /*
10453 * dumpNamespace
10454 * writes out to fout the queries to recreate a user-defined namespace
10455 */
10456 static void
10458 {
10460 PQExpBuffer q;
10461 PQExpBuffer delq;
10464 /* Do nothing in data-only dump */
10474 {
10477 }
10478 else
10479 {
10480 /* see selectDumpableNamespace() */
10485 }
10500 /* Dump Schema Comments and Security Labels */
10502 {
10510 initdb_comment);
10511 }
10527 }
10529 /*
10530 * dumpExtension
10531 * writes out to fout the queries to recreate an extension
10532 */
10533 static void
10535 {
10537 PQExpBuffer q;
10538 PQExpBuffer delq;
10541 /* Do nothing in data-only dump */
10553 {
10554 /*
10555 * In a regular dump, we simply create the extension, intentionally
10556 * not specifying a version, so that the destination installation's
10557 * default version is used.
10558 *
10559 * Use of IF NOT EXISTS here is unlike our behavior for other object
10560 * types; but there are various scenarios in which it's convenient to
10561 * manually create the desired extension before restoring, so we
10562 * prefer to allow it to exist already.
10563 */
10566 }
10567 else
10568 {
10569 /*
10570 * In binary-upgrade mode, it's critical to reproduce the state of the
10571 * database exactly, so our procedure is to create an empty extension,
10572 * restore all the contained objects normally, and add them to the
10573 * extension one by one. This function performs just the first of
10574 * those steps. binary_upgrade_extension_member() takes care of
10575 * adding member objects as they're created.
10576 */
10580 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
10582 /*
10583 * We unconditionally create the extension, so we must drop it if it
10584 * exists. This could happen if the user deleted 'plpgsql' and then
10585 * readded it, causing its oid to be greater than g_last_builtin_oid.
10586 */
10599 /*
10600 * Note that we're pushing extconfig (an OID array) back into
10601 * pg_extension exactly as-is. This is OK because pg_class OIDs are
10602 * preserved in binary upgrade.
10603 */
10606 else
10611 else
10617 {
10622 {
10626 }
10627 }
10630 }
10640 /* Dump Extension Comments and Security Labels */
10655 }
10657 /*
10658 * dumpType
10659 * writes out to fout the queries to recreate a user-defined type
10660 */
10661 static void
10663 {
10666 /* Do nothing in data-only dump */
10670 /* Dump out in proper style */
10683 else
10686 }
10688 /*
10689 * dumpEnumType
10690 * writes out to fout the queries to recreate a user-defined enum type
10691 */
10692 static void
10694 {
10701 i;
10702 Oid enum_oid;
10710 {
10711 /* Set up query for enum-specific details */
10714 "SELECT oid, enumlabel "
10715 "FROM pg_catalog.pg_enum "
10716 "WHERE enumtypid = $1 "
10722 }
10735 /*
10736 * CASCADE shouldn't be required here as for normal types since the I/O
10737 * functions are generic and do not get dropped.
10738 */
10747 qualtypname);
10750 {
10753 /* Labels with server-assigned oids */
10755 {
10761 }
10762 }
10767 {
10771 /* Labels with dump-assigned (preserved) oids */
10773 {
10781 enum_oid);
10785 }
10786 }
10803 /* Dump Type Comments and Security Labels */
10826 }
10828 /*
10829 * dumpRangeType
10830 * writes out to fout the queries to recreate a user-defined range type
10831 */
10832 static void
10834 {
10840 Oid collationOid;
10846 {
10847 /* Set up query for range-specific details */
10857 else
10862 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
10863 "opc.opcname AS opcname, "
10864 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
10865 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
10866 "opc.opcdefault, "
10867 "CASE WHEN rngcollation = st.typcollation THEN 0 "
10868 " ELSE rngcollation END AS collation, "
10869 "rngcanonical, rngsubdiff "
10870 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
10871 " pg_catalog.pg_opclass opc "
10872 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
10878 }
10889 /*
10890 * CASCADE shouldn't be required here as for normal types since the I/O
10891 * functions are generic and do not get dropped.
10892 */
10901 qualtypname);
10910 /* print subtype_opclass only if not default for subtype */
10912 {
10919 }
10923 {
10929 }
10956 /* Dump Type Comments and Security Labels */
10979 }
10981 /*
10982 * dumpUndefinedType
10983 * writes out to fout the queries to recreate a !typisdefined type
10984 *
10985 * This is a shell type, but we use different terminology to distinguish
10986 * this case from where we have to emit a shell type definition to break
10987 * circular dependencies. An undefined type shouldn't ever have anything
10988 * depending on it.
10989 */
10990 static void
10992 {
11010 qualtypname);
11027 /* Dump Type Comments and Security Labels */
11048 }
11050 /*
11051 * dumpBaseType
11052 * writes out to fout the queries to recreate a user-defined base type
11053 */
11054 static void
11056 {
11073 Oid typreceiveoid;
11074 Oid typsendoid;
11075 Oid typmodinoid;
11076 Oid typmodoutoid;
11077 Oid typanalyzeoid;
11078 Oid typsubscriptoid;
11090 {
11091 /* Set up query for type-specific details */
11094 "SELECT typlen, "
11095 "typinput, typoutput, typreceive, typsend, "
11096 "typreceive::pg_catalog.oid AS typreceiveoid, "
11097 "typsend::pg_catalog.oid AS typsendoid, "
11098 "typanalyze, "
11099 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
11100 "typdelim, typbyval, typalign, typstorage, "
11101 "typmodin, typmodout, "
11102 "typmodin::pg_catalog.oid AS typmodinoid, "
11103 "typmodout::pg_catalog.oid AS typmodoutoid, "
11104 "typcategory, typispreferred, "
11105 "(typcollation <> 0) AS typcollatable, "
11110 "typsubscript, "
11112 else
11122 }
11155 {
11158 }
11159 else
11165 /*
11166 * The reason we include CASCADE is that the circular dependency between
11167 * the type and its I/O functions makes it impossible to drop the type any
11168 * other way.
11169 */
11172 /*
11173 * We might already have a shell type, but setting pg_type_oid is
11174 * harmless, and in any case we'd better set the array type OID.
11175 */
11184 qualtypname,
11187 /* regproc result is sufficiently quoted already */
11205 {
11209 else
11211 }
11219 zeroIsError));
11222 {
11225 }
11231 {
11234 }
11274 /* Dump Type Comments and Security Labels */
11297 }
11299 /*
11300 * dumpDomain
11301 * writes out to fout the queries to recreate a user-defined domain
11302 */
11303 static void
11305 {
11317 Oid typcollation;
11321 {
11322 /* Set up query for domain-specific details */
11327 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
11328 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
11329 "t.typdefault, "
11330 "CASE WHEN t.typcollation <> u.typcollation "
11331 "THEN t.typcollation ELSE 0 END AS typcollation "
11332 "FROM pg_catalog.pg_type t "
11333 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
11339 }
11352 {
11355 }
11356 else
11371 qualtypname,
11372 typdefn);
11374 /* Print collation only if different from base type's collation */
11376 {
11382 }
11388 {
11392 else
11394 }
11398 /*
11399 * Add any CHECK constraints for the domain
11400 */
11402 {
11408 }
11429 /* Dump Domain Comments and Security Labels */
11446 /* Dump any per-constraint comments */
11448 {
11462 }
11469 }
11471 /*
11472 * dumpCompositeType
11473 * writes out to fout the queries to recreate a user-defined stand-alone
11474 * composite type
11475 */
11476 static void
11478 {
11498 {
11499 /*
11500 * Set up query for type-specific details.
11501 *
11502 * Since we only want to dump COLLATE clauses for attributes whose
11503 * collation is different from their type's default, we use a CASE
11504 * here to suppress uninteresting attcollations cheaply. atttypid
11505 * will be 0 for dropped columns; collation does not matter for those.
11506 */
11509 "SELECT a.attname, a.attnum, "
11510 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
11511 "a.attlen, a.attalign, a.attisdropped, "
11512 "CASE WHEN a.attcollation <> at.typcollation "
11513 "THEN a.attcollation ELSE 0 END AS attcollation "
11514 "FROM pg_catalog.pg_type ct "
11515 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
11516 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
11517 "WHERE ct.oid = $1 "
11523 }
11541 {
11546 }
11552 qualtypname);
11556 {
11562 Oid attcollation;
11574 /* Format properly if not first attr */
11580 {
11583 /* Add collation if not default for the column type */
11585 {
11592 }
11593 }
11594 else
11595 {
11596 /*
11597 * This is a dropped attribute and we're in binary_upgrade mode.
11598 * Insert a placeholder for it in the CREATE TYPE command, and set
11599 * length and alignment with direct UPDATE to the catalogs
11600 * afterwards. See similar code in dumpTableSchema().
11601 */
11604 /* stash separately for insertion after the CREATE TYPE */
11608 "SET attlen = %s, "
11617 qualtypname);
11620 }
11621 }
11643 /* Dump Type Comments and Security Labels */
11660 /* Dump any per-column comments */
11671 }
11673 /*
11674 * dumpCompositeTypeColComments
11675 * writes out to fout the queries to recreate comments on the columns of
11676 * a user-defined stand-alone composite type.
11677 *
11678 * The caller has already made a query to collect the names and attnums
11679 * of the type's columns, so we just pass that result into here rather
11680 * than reading them again.
11681 */
11682 static void
11685 {
11688 PQExpBuffer query;
11689 PQExpBuffer target;
11696 /* do nothing, if --no-comments is supplied */
11700 /* Search for comments associated with type's pg_class OID */
11704 /* If no comments exist, we're done */
11708 /* Build COMMENT ON statements */
11717 {
11722 {
11725 {
11728 }
11729 }
11731 {
11755 }
11757 comments++;
11758 ncomments--;
11759 }
11763 }
11765 /*
11766 * dumpShellType
11767 * writes out to fout the queries to create a shell type
11768 *
11769 * We dump a shell definition in advance of the I/O functions for the type.
11770 */
11771 static void
11773 {
11775 PQExpBuffer q;
11777 /* Do nothing in data-only dump */
11783 /*
11784 * Note the lack of a DROP command for the shell type; any required DROP
11785 * is driven off the base type entry, instead. This interacts with
11786 * _printTocEntry()'s use of the presence of a DROP command to decide
11787 * whether an entry needs an ALTER OWNER command. We don't want to alter
11788 * the shell type's owner immediately on creation; that should happen only
11789 * after it's filled in, otherwise the backend complains.
11790 */
11810 }
11812 /*
11813 * dumpProcLang
11814 * writes out to fout the queries to recreate a user-defined
11815 * procedural language
11816 */
11817 static void
11819 {
11821 PQExpBuffer defqry;
11822 PQExpBuffer delqry;
11829 /* Do nothing in data-only dump */
11833 /*
11834 * Try to find the support function(s). It is not an error if we don't
11835 * find them --- if the functions are in the pg_catalog schema, as is
11836 * standard in 8.1 and up, then we won't have loaded them. (In this case
11837 * we will emit a parameterless CREATE LANGUAGE command, which will
11838 * require PL template knowledge in the backend to reload.)
11839 */
11846 {
11850 }
11853 {
11857 }
11859 /*
11860 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
11861 * parameters. Otherwise, we'll write a parameterless command, which will
11862 * be interpreted as CREATE EXTENSION.
11863 */
11874 qlanname);
11877 {
11880 qlanname);
11889 }
11890 else
11891 {
11892 /*
11893 * If not dumping parameters, then use CREATE OR REPLACE so that the
11894 * command will not fail if the language is preinstalled in the target
11895 * database.
11896 *
11897 * Modern servers will interpret this as CREATE EXTENSION IF NOT
11898 * EXISTS; perhaps we should emit that instead? But it might just add
11899 * confusion.
11900 */
11902 qlanname);
11903 }
11918 ));
11920 /* Dump Proc Lang Comments and Security Labels */
11940 }
11942 /*
11943 * format_function_arguments: generate function name and argument list
11944 *
11945 * This is used when we can rely on pg_get_function_arguments to format
11946 * the argument list. Note, however, that pg_get_function_arguments
11947 * does not special-case zero-argument aggregates.
11948 */
11951 {
11952 PQExpBufferData fn;
11958 else
11961 }
11963 /*
11964 * format_function_signature: generate function name and argument list
11965 *
11966 * Only a minimal list of input argument types is generated; this is
11967 * sufficient to reference the function, but not to define it.
11968 *
11969 * If honor_quotes is false then the function name is never quoted.
11970 * This is appropriate for use in TOC tags, but not in SQL commands.
11971 */
11974 {
11975 PQExpBufferData fn;
11981 else
11984 {
11990 zeroIsError));
11991 }
11994 }
11997 /*
11998 * dumpFunc:
11999 * dump out one function
12000 */
12001 static void
12003 {
12005 PQExpBuffer query;
12006 PQExpBuffer q;
12007 PQExpBuffer delqry;
12008 PQExpBuffer asPart;
12037 /* Do nothing in data-only dump */
12047 {
12048 /* Set up query for function-specific details */
12072 else
12079 else
12086 else
12093 else
12100 else
12106 "WHERE p.oid = $1 "
12112 }
12122 {
12126 }
12127 else
12128 {
12132 }
12149 /*
12150 * See backend/commands/functioncmds.c for details of how the 'AS' clause
12151 * is used.
12152 */
12154 {
12156 }
12158 {
12162 {
12165 /*
12166 * where we have bin, use dollar quoting if allowed and src
12167 * contains quote or backslash; else use regular quoting.
12168 */
12172 else
12174 }
12175 }
12176 else
12177 {
12179 /* with no bin, dollar quote src unconditionally if allowed */
12182 else
12184 }
12187 {
12190 }
12191 else
12192 {
12195 }
12204 funcsig);
12208 else
12215 keyword,
12218 funcsig);
12224 else
12228 zeroIsError));
12233 {
12240 {
12245 }
12246 }
12252 {
12260 }
12271 /*
12272 * COST and ROWS are emitted only if present and not default, so as not to
12273 * break backwards-compatibility of the dump without need. Keep this code
12274 * in sync with the defaults in functioncmds.c.
12275 */
12277 {
12279 {
12280 /* default cost is 1 */
12283 }
12284 else
12285 {
12286 /* default cost is 100 */
12289 }
12290 }
12296 {
12297 /* We rely on regprocout to provide quoting and qualification */
12299 }
12302 {
12310 }
12313 {
12314 /* we feel free to scribble on configitems[] here */
12324 /*
12325 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
12326 * by flatten_set_variable_args() before they were put into the
12327 * proconfig array. However, because the quoting rules used there
12328 * aren't exactly like SQL's, we have to break the list value apart
12329 * and then quote the elements as string literals. (The elements may
12330 * be double-quoted as-is, but we can't just feed them to the SQL
12331 * parser; it would do the wrong thing with elements that are
12332 * zero-length or longer than NAMEDATALEN.)
12333 *
12334 * Variables that are not so marked should just be emitted as simple
12335 * string literals. If the variable is not known to
12336 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
12337 * to use GUC_LIST_QUOTE for extension variables.
12338 */
12340 {
12344 /* Parse string into list of identifiers */
12345 /* this shouldn't fail really */
12347 {
12349 {
12353 }
12354 }
12356 }
12357 else
12359 }
12365 qual_funcsig);
12383 /* Dump Function Comments and Security Labels */
12411 }
12414 /*
12415 * Dump a user-defined cast
12416 */
12417 static void
12419 {
12421 PQExpBuffer defqry;
12422 PQExpBuffer delqry;
12423 PQExpBuffer labelq;
12424 PQExpBuffer castargs;
12429 /* Do nothing in data-only dump */
12433 /* Cannot dump if we don't have the cast function's info */
12435 {
12440 }
12456 {
12465 {
12468 /*
12469 * Always qualify the function name (format_function_signature
12470 * won't qualify it).
12471 */
12475 }
12476 else
12481 }
12507 /* Dump Cast Comments */
12517 }
12519 /*
12520 * Dump a transform
12521 */
12522 static void
12524 {
12526 PQExpBuffer defqry;
12527 PQExpBuffer delqry;
12528 PQExpBuffer labelq;
12529 PQExpBuffer transformargs;
12535 /* Do nothing in data-only dump */
12539 /* Cannot dump if we don't have the transform functions' info */
12541 {
12546 }
12548 {
12553 }
12570 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
12573 {
12575 {
12578 /*
12579 * Always qualify the function name (format_function_signature
12580 * won't qualify it).
12581 */
12585 }
12586 else
12588 }
12591 {
12596 {
12599 /*
12600 * Always qualify the function name (format_function_signature
12601 * won't qualify it).
12602 */
12606 }
12607 else
12609 }
12633 /* Dump Transform Comments */
12644 }
12647 /*
12648 * dumpOpr
12649 * write out a single operator definition
12650 */
12651 static void
12653 {
12655 PQExpBuffer query;
12656 PQExpBuffer q;
12657 PQExpBuffer delq;
12658 PQExpBuffer oprid;
12659 PQExpBuffer details;
12684 /* Do nothing in data-only dump */
12688 /*
12689 * some operators are invalid because they were the result of user
12690 * defining operators before commutators exist
12691 */
12702 {
12703 /* Set up query for operator-specific details */
12706 "SELECT oprkind, "
12707 "oprcode::pg_catalog.regprocedure, "
12708 "oprleft::pg_catalog.regtype, "
12709 "oprright::pg_catalog.regtype, "
12710 "oprcom, "
12711 "oprnegate, "
12712 "oprrest::pg_catalog.regprocedure, "
12713 "oprjoin::pg_catalog.regprocedure, "
12714 "oprcanmerge, oprcanhash "
12715 "FROM pg_catalog.pg_operator "
12721 }
12751 /* In PG14 upwards postfix operator support does not exist anymore. */
12754 oprcode);
12758 {
12761 }
12766 /*
12767 * right unary means there's a left arg and left unary means there's a
12768 * right arg. (Although the "r" case is dead code for PG14 and later,
12769 * continue to support it in case we're dumping from an old server.)
12770 */
12773 {
12776 }
12777 else
12782 {
12785 }
12786 else
12791 {
12794 }
12798 {
12801 }
12811 {
12814 }
12818 {
12821 }
12846 /* Dump Operator Comments */
12859 }
12861 /*
12862 * Convert a function reference obtained from pg_operator
12863 *
12864 * Returns allocated string of what to print, or NULL if function references
12865 * is InvalidOid. Returned string is expected to be free'd by the caller.
12866 *
12867 * The input is a REGPROCEDURE display; we have to strip the argument-types
12868 * part.
12869 */
12872 {
12877 /* In all cases "-" means a null reference */
12882 /* find non-double-quoted left paren */
12885 {
12887 {
12890 }
12893 }
12895 }
12897 /*
12898 * getFormattedOperatorName - retrieve the operator name for the
12899 * given operator OID (presented in string form).
12900 *
12901 * Returns an allocated string, or NULL if the given OID is invalid.
12902 * Caller is responsible for free'ing result string.
12903 *
12904 * What we produce has the format "OPERATOR(schema.oprname)". This is only
12905 * useful in commands where the operator's argument types can be inferred from
12906 * context. We always schema-qualify the name, though. The predecessor to
12907 * this code tried to skip the schema qualification if possible, but that led
12908 * to wrong results in corner cases, such as if an operator and its negator
12909 * are in different schemas.
12910 */
12913 {
12916 /* In all cases "0" means a null reference */
12922 {
12924 oproid);
12926 }
12931 }
12933 /*
12934 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
12935 *
12936 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
12937 * argument lists of these functions are predetermined. Note that the
12938 * caller should ensure we are in the proper schema, because the results
12939 * are search path dependent!
12940 */
12943 {
12957 }
12959 /*
12960 * dumpAccessMethod
12961 * write out a single access method definition
12962 */
12963 static void
12965 {
12967 PQExpBuffer q;
12968 PQExpBuffer delq;
12971 /* Do nothing in data-only dump */
12983 {
12997 }
13002 qamname);
13016 /* Dump Access Method Comments */
13025 }
13027 /*
13028 * dumpOpclass
13029 * write out a single operator class definition
13030 */
13031 static void
13033 {
13035 PQExpBuffer query;
13036 PQExpBuffer q;
13037 PQExpBuffer delq;
13038 PQExpBuffer nameusing;
13074 /* Do nothing in data-only dump */
13083 /* Get additional fields from the pg_opclass row */
13085 "opckeytype::pg_catalog.regtype, "
13086 "opcdefault, opcfamily, "
13087 "opfname AS opcfamilyname, "
13088 "nspname AS opcfamilynsp, "
13089 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
13090 "FROM pg_catalog.pg_opclass c "
13091 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
13092 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13106 /* opcintype may still be needed after we PQclear res */
13110 /* opcfamily will still be needed after we PQclear res */
13114 /* amname will still be needed after we PQclear res */
13122 /* Build the fixed portion of the CREATE command */
13128 opcintype,
13131 {
13135 }
13141 {
13143 opckeytype);
13145 }
13149 /*
13150 * Now fetch and print the OPERATOR entries (pg_amop rows).
13151 *
13152 * Print only those opfamily members that are tied to the opclass by
13153 * pg_depend entries.
13154 */
13157 "amopopr::pg_catalog.regoperator, "
13158 "opfname AS sortfamily, "
13159 "nspname AS sortfamilynsp "
13160 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13161 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13162 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13163 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13164 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13165 "AND refobjid = '%u'::pg_catalog.oid "
13166 "AND amopfamily = '%s'::pg_catalog.oid "
13169 opcfamily);
13181 {
13194 {
13198 }
13201 }
13205 /*
13206 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13207 *
13208 * Print only those opfamily members that are tied to the opclass by
13209 * pg_depend entries.
13210 *
13211 * We print the amproclefttype/amprocrighttype even though in most cases
13212 * the backend could deduce the right values, because of the corner case
13213 * of a btree sort support function for a cross-type comparison.
13214 */
13218 "amproc::pg_catalog.regprocedure, "
13219 "amproclefttype::pg_catalog.regtype, "
13220 "amprocrighttype::pg_catalog.regtype "
13221 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13222 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13223 "AND refobjid = '%u'::pg_catalog.oid "
13224 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13225 "AND objid = ap.oid "
13239 {
13256 }
13260 /*
13261 * If needComma is still false it means we haven't added anything after
13262 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
13263 * clause with the same datatype. This isn't sanctioned by the
13264 * documentation, but actually DefineOpClass will treat it as a no-op.
13265 */
13290 /* Dump Operator Class Comments */
13303 }
13305 /*
13306 * dumpOpfamily
13307 * write out a single operator family definition
13308 *
13309 * Note: this also dumps any "loose" operator members that aren't bound to a
13310 * specific opclass within the opfamily.
13311 */
13312 static void
13314 {
13316 PQExpBuffer query;
13317 PQExpBuffer q;
13318 PQExpBuffer delq;
13319 PQExpBuffer nameusing;
13345 /* Do nothing in data-only dump */
13354 /*
13355 * Fetch only those opfamily members that are tied directly to the
13356 * opfamily by pg_depend entries.
13357 */
13359 "amopopr::pg_catalog.regoperator, "
13360 "opfname AS sortfamily, "
13361 "nspname AS sortfamilynsp "
13362 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13363 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13364 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13365 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13366 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13367 "AND refobjid = '%u'::pg_catalog.oid "
13368 "AND amopfamily = '%u'::pg_catalog.oid "
13378 "amproc::pg_catalog.regprocedure, "
13379 "amproclefttype::pg_catalog.regtype, "
13380 "amprocrighttype::pg_catalog.regtype "
13381 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13382 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13383 "AND refobjid = '%u'::pg_catalog.oid "
13384 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13385 "AND objid = ap.oid "
13391 /* Get additional fields from the pg_opfamily row */
13395 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
13396 "FROM pg_catalog.pg_opfamily "
13404 /* amname will still be needed after we PQclear res */
13412 /* Build the fixed portion of the CREATE command */
13420 /* Do we need an ALTER to add loose members? */
13422 {
13430 /*
13431 * Now fetch and print the OPERATOR entries (pg_amop rows).
13432 */
13441 {
13454 {
13458 }
13461 }
13463 /*
13464 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13465 */
13474 {
13485 amproc);
13488 }
13491 }
13512 /* Dump Operator Family Comments */
13525 }
13527 /*
13528 * dumpCollation
13529 * write out a single collation definition
13530 */
13531 static void
13533 {
13535 PQExpBuffer query;
13536 PQExpBuffer q;
13537 PQExpBuffer delq;
13552 /* Do nothing in data-only dump */
13562 /* Get collation-specific details */
13567 "collprovider, "
13569 else
13571 "'c' AS collprovider, "
13577 else
13584 else
13591 else
13596 "collcollate, "
13597 "collctype "
13598 "FROM pg_catalog.pg_collation c "
13615 else
13620 else
13623 /*
13624 * Before version 15, collcollate and collctype were of type NAME and
13625 * non-nullable. Treat empty strings as NULL for consistency.
13626 */
13628 {
13633 }
13637 else
13642 else
13657 /* to allow dumping pg_catalog; not accepted on input */
13659 else
13661 collprovider);
13667 {
13671 /* no locale -- the default collation cannot be reloaded anyway */
13672 }
13674 {
13676 {
13682 fout);
13683 }
13684 else
13685 {
13692 }
13695 {
13698 }
13699 }
13701 {
13706 {
13709 }
13710 else
13711 {
13716 }
13717 }
13718 else
13721 /*
13722 * For binary upgrade, carry over the collation version. For normal
13723 * dump/restore, omit the version, so that it is computed upon restore.
13724 */
13726 {
13731 {
13735 fout);
13736 }
13737 }
13756 /* Dump Collation Comments */
13768 }
13770 /*
13771 * dumpConversion
13772 * write out a single conversion definition
13773 */
13774 static void
13776 {
13778 PQExpBuffer query;
13779 PQExpBuffer q;
13780 PQExpBuffer delq;
13792 /* Do nothing in data-only dump */
13802 /* Get conversion-specific details */
13804 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
13805 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
13806 "conproc, condefault "
13807 "FROM pg_catalog.pg_conversion c "
13832 /* regproc output is already sufficiently quoted */
13850 /* Dump Conversion Comments */
13862 }
13864 /*
13865 * format_aggregate_signature: generate aggregate name and argument list
13866 *
13867 * The argument type names are qualified if needed. The aggregate name
13868 * is never qualified.
13869 */
13872 {
13873 PQExpBufferData buf;
13879 else
13884 else
13885 {
13892 zeroIsError));
13894 }
13896 }
13898 /*
13899 * dumpAgg
13900 * write out a single aggregate definition
13901 */
13902 static void
13904 {
13906 PQExpBuffer query;
13907 PQExpBuffer q;
13908 PQExpBuffer delq;
13909 PQExpBuffer details;
13940 /* Do nothing in data-only dump */
13950 {
13951 /* Set up query for aggregate-specific details */
13956 "SELECT "
13977 else
13996 else
14007 else
14013 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14014 "WHERE a.aggfnoid = p.oid "
14020 }
14053 {
14061 }
14065 /* identify default modify flag for aggkind (must match DefineAggregate) */
14066 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
14067 /* replace omitted flags for old versions */
14073 /* regproc and regtype output is already sufficiently quoted */
14078 {
14080 aggtransspace);
14081 }
14084 {
14087 }
14090 {
14092 aggfinalfn);
14096 {
14098 {
14112 }
14113 }
14114 }
14126 {
14128 aggmtransfn,
14129 aggminvtransfn,
14130 aggmtranstype);
14131 }
14134 {
14136 aggmtransspace);
14137 }
14140 {
14143 }
14146 {
14148 aggmfinalfn);
14152 {
14154 {
14168 }
14169 }
14170 }
14174 {
14176 aggsortconvop);
14178 }
14184 {
14192 }
14196 aggsig);
14218 /* Dump Aggregate Comments */
14231 /*
14232 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
14233 * command look like a function's GRANT; in particular this affects the
14234 * syntax for zero-argument aggregates and ordered-set aggregates.
14235 */
14256 }
14258 /*
14259 * dumpTSParser
14260 * write out a single text search parser
14261 */
14262 static void
14264 {
14266 PQExpBuffer q;
14267 PQExpBuffer delq;
14270 /* Do nothing in data-only dump */
14311 /* Dump Parser Comments */
14320 }
14322 /*
14323 * dumpTSDictionary
14324 * write out a single text search dictionary
14325 */
14326 static void
14328 {
14330 PQExpBuffer q;
14331 PQExpBuffer delq;
14332 PQExpBuffer query;
14338 /* Do nothing in data-only dump */
14348 /* Fetch name and namespace of the dictionary's template */
14350 "FROM pg_ts_template p, pg_namespace n "
14366 /* the dictinitoption can be dumped straight into the command */
14390 /* Dump Dictionary Comments */
14400 }
14402 /*
14403 * dumpTSTemplate
14404 * write out a single text search template
14405 */
14406 static void
14408 {
14410 PQExpBuffer q;
14411 PQExpBuffer delq;
14414 /* Do nothing in data-only dump */
14449 /* Dump Template Comments */
14458 }
14460 /*
14461 * dumpTSConfig
14462 * write out a single text search configuration
14463 */
14464 static void
14466 {
14468 PQExpBuffer q;
14469 PQExpBuffer delq;
14470 PQExpBuffer query;
14476 i;
14480 /* Do nothing in data-only dump */
14490 /* Fetch name and namespace of the config's parser */
14492 "FROM pg_ts_parser p, pg_namespace n "
14525 {
14531 {
14532 /* starting a new token type, so start a new command */
14537 /* tokenname needs quoting, dictname does NOT */
14540 }
14541 else
14543 }
14568 /* Dump Configuration Comments */
14578 }
14580 /*
14581 * dumpForeignDataWrapper
14582 * write out a single foreign-data wrapper definition
14583 */
14584 static void
14586 {
14588 PQExpBuffer q;
14589 PQExpBuffer delq;
14592 /* Do nothing in data-only dump */
14602 qfdwname);
14616 qfdwname);
14621 NULL);
14632 /* Dump Foreign Data Wrapper Comments */
14638 /* Handle the ACL */
14648 }
14650 /*
14651 * dumpForeignServer
14652 * write out a foreign server definition
14653 */
14654 static void
14656 {
14658 PQExpBuffer q;
14659 PQExpBuffer delq;
14660 PQExpBuffer query;
14665 /* Do nothing in data-only dump */
14675 /* look up the foreign-data wrapper */
14677 "FROM pg_foreign_data_wrapper w "
14685 {
14688 }
14690 {
14693 }
14704 qsrvname);
14719 /* Dump Foreign Server Comments */
14725 /* Handle the ACL */
14731 /* Dump user mappings */
14745 }
14747 /*
14748 * dumpUserMappings
14749 *
14750 * This routine is used to dump any user mappings associated with the
14751 * server handed to this routine. Should be called after ArchiveEntry()
14752 * for the server.
14753 */
14754 static void
14759 {
14760 PQExpBuffer q;
14761 PQExpBuffer delq;
14762 PQExpBuffer query;
14763 PQExpBuffer tag;
14775 /*
14776 * We read from the publicly accessible view pg_user_mappings, so as not
14777 * to fail if run by a non-superuser. Note that the view will show
14778 * umoptions as null if the user hasn't got privileges for the associated
14779 * server; this means that pg_dump will dump such a mapping, but with no
14780 * OPTIONS clause. A possible alternative is to skip such mappings
14781 * altogether, but it's not clear that that's an improvement.
14782 */
14784 "SELECT usename, "
14785 "array_to_string(ARRAY("
14786 "SELECT quote_ident(option_name) || ' ' || "
14787 "quote_literal(option_value) "
14788 "FROM pg_options_to_table(umoptions) "
14789 "ORDER BY option_name"
14791 "FROM pg_user_mappings "
14792 "WHERE srvid = '%u' "
14803 {
14835 }
14843 }
14845 /*
14846 * Write out default privileges information
14847 */
14848 static void
14850 {
14852 PQExpBuffer q;
14853 PQExpBuffer tag;
14856 /* Do nothing in data-only dump, or if we're skipping ACLs */
14864 {
14881 /* shouldn't get here */
14885 }
14889 /* build the actual command(s) for this tuple */
14897 q))
14913 }
14915 /*----------
14916 * Write out grant/revoke information
14917 *
14918 * 'objDumpId' is the dump ID of the underlying object.
14919 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
14920 * or InvalidDumpId if there is no need for a second dependency.
14921 * 'type' must be one of
14922 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
14923 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
14924 * 'name' is the formatted name of the object. Must be quoted etc. already.
14925 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
14926 * (Currently we assume that subname is only provided for table columns.)
14927 * 'nspname' is the namespace the object is in (NULL if none).
14928 * 'owner' is the owner, NULL if there is no owner (for languages).
14929 * 'dacl' is the DumpableAcl struct fpr the object.
14930 *
14931 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
14932 * no ACL entry was created.
14933 *----------
14934 */
14935 static DumpId
14940 {
14948 PQExpBuffer sql;
14950 /* Do nothing if ACL dump is not enabled */
14954 /* --data-only skips ACLs *except* large object ACLs */
14960 /*
14961 * In binary upgrade mode, we don't run an extension's script but instead
14962 * dump out the objects independently and then recreate them. To preserve
14963 * any initial privileges which were set on extension objects, we need to
14964 * compute the set of GRANT and REVOKE commands necessary to get from the
14965 * default privileges of an object to its initial privileges as recorded
14966 * in pg_init_privs.
14967 *
14968 * At restore time, we apply these commands after having called
14969 * binary_upgrade_set_record_init_privs(true). That tells the backend to
14970 * copy the results into pg_init_privs. This is how we preserve the
14971 * contents of that catalog across binary upgrades.
14972 */
14975 {
14982 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
14983 }
14985 /*
14986 * Now figure the GRANT and REVOKE commands needed to get to the object's
14987 * actual current ACL, starting from the initprivs if given, else from the
14988 * object-type-specific default. Also, while buildACLCommands will assume
14989 * that a NULL/empty acls string means it needn't do anything, what that
14990 * actually represents is the object-type-specific default; so we need to
14991 * substitute the acldefault string to get the right results in that case.
14992 */
14994 {
14998 }
14999 else
15009 {
15016 else
15036 }
15041 }
15043 /*
15044 * dumpSecLabel
15045 *
15046 * This routine is used to dump any security labels associated with the
15047 * object handed to this routine. The routine takes the object type
15048 * and object name (ready to print, except for schema decoration), plus
15049 * the namespace and owner of the object (for labeling the ArchiveEntry),
15050 * plus catalog ID and subid which are the lookup key for pg_seclabel,
15051 * plus the dump ID for the object (for setting a dependency).
15052 * If a matching pg_seclabel entry is found, it is dumped.
15053 *
15054 * Note: although this routine takes a dumpId for dependency purposes,
15055 * that purpose is just to mark the dependency in the emitted dump file
15056 * for possible future use by pg_restore. We do NOT use it for determining
15057 * ordering of the label in the dump file, because this routine is called
15058 * after dependency sorting occurs. This routine should be called just after
15059 * calling ArchiveEntry() for the specified object.
15060 */
15061 static void
15065 {
15070 PQExpBuffer query;
15072 /* do nothing, if --no-security-labels is supplied */
15076 /*
15077 * Security labels are schema not data ... except large object labels are
15078 * data
15079 */
15081 {
15084 }
15085 else
15086 {
15087 /* We do dump large object security labels in binary-upgrade mode */
15090 }
15092 /* Search for security labels associated with catalogId, using table */
15098 {
15099 /*
15100 * Ignore label entries for which the subid doesn't match.
15101 */
15113 }
15116 {
15130 }
15133 }
15135 /*
15136 * dumpTableSecLabel
15137 *
15138 * As above, but dump security label for both the specified table (or view)
15139 * and its columns.
15140 */
15141 static void
15143 {
15148 PQExpBuffer query;
15149 PQExpBuffer target;
15151 /* do nothing, if --no-security-labels is supplied */
15155 /* SecLabel are SCHEMA not data */
15159 /* Search for comments associated with relation, using table */
15164 /* If security labels exist, build SECURITY LABEL statements */
15172 {
15180 {
15183 }
15184 else
15185 {
15187 /* first fmtXXX result must be consumed before calling again */
15191 }
15196 }
15198 {
15211 }
15214 }
15216 /*
15217 * findSecLabels
15218 *
15219 * Find the security label(s), if any, associated with the given object.
15220 * All the objsubid values associated with the given classoid/objoid are
15221 * found with one search.
15222 */
15223 static int
15225 {
15232 {
15235 }
15237 /*
15238 * Do binary search to find some item matching the object.
15239 */
15243 {
15254 else
15256 }
15259 {
15262 }
15264 /*
15265 * Now determine how many items match the object. The search loop
15266 * invariant still holds: only items between low and high inclusive could
15267 * match.
15268 */
15271 {
15275 middle--;
15276 nmatch++;
15277 }
15283 {
15287 middle++;
15288 nmatch++;
15289 }
15292 }
15294 /*
15295 * collectSecLabels
15296 *
15297 * Construct a table of all security labels available for database objects;
15298 * also set the has-seclabel component flag for each relevant object.
15299 *
15300 * The table is sorted by classoid/objid/objsubid for speed in lookup.
15301 */
15302 static void
15304 {
15306 PQExpBuffer query;
15319 "SELECT label, provider, classoid, objoid, objsubid "
15320 "FROM pg_catalog.pg_seclabel "
15325 /* Construct lookup table containing OIDs in numeric form */
15339 {
15340 CatalogId objId;
15347 /* We needn't remember labels that don't match any dumpable object */
15355 /*
15356 * Labels on columns of composite types are linked to the type's
15357 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
15358 * in the type's own DumpableObject.
15359 */
15362 {
15368 }
15369 else
15377 nseclabels++;
15378 }
15382 }
15384 /*
15385 * dumpTable
15386 * write out to fout the declarations (not data) of a user-defined table
15387 */
15388 static void
15390 {
15395 /* Do nothing in data-only dump */
15400 {
15403 else
15405 }
15407 /* Handle the ACL here */
15410 {
15414 tableAclDumpId =
15419 }
15421 /*
15422 * Handle column ACLs, if any. Note: we pull these with a separate query
15423 * rather than trying to fetch them during getTableAttrs, so that we won't
15424 * miss ACLs on system columns. Doing it this way also allows us to dump
15425 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
15426 */
15428 {
15434 {
15435 /* Set up query for column ACLs */
15440 {
15441 /*
15442 * In principle we should call acldefault('c', relowner) to
15443 * get the default ACL for a column. However, we don't
15444 * currently store the numeric OID of the relowner in
15445 * TableInfo. We could convert the owner name using regrole,
15446 * but that creates a risk of failure due to concurrent role
15447 * renames. Given that the default ACL for columns is empty
15448 * and is likely to stay that way, it's not worth extra cycles
15449 * and risk to avoid hard-wiring that knowledge here.
15450 */
15452 "SELECT at.attname, "
15453 "at.attacl, "
15454 "'{}' AS acldefault, "
15455 "pip.privtype, pip.initprivs "
15456 "FROM pg_catalog.pg_attribute at "
15457 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
15458 "(at.attrelid = pip.objoid "
15459 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
15460 "AND at.attnum = pip.objsubid) "
15461 "WHERE at.attrelid = $1 AND "
15462 "NOT at.attisdropped "
15463 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
15465 }
15466 else
15467 {
15469 "SELECT attname, attacl, '{}' AS acldefault, "
15470 "NULL AS privtype, NULL AS initprivs "
15471 "FROM pg_catalog.pg_attribute "
15472 "WHERE attrelid = $1 AND NOT attisdropped "
15473 "AND attacl IS NOT NULL "
15475 }
15480 }
15489 {
15495 DumpableAcl coldacl;
15504 /*
15505 * Column's GRANT type is always TABLE. Each column ACL depends
15506 * on the table-level ACL, since we can restore column ACLs in
15507 * parallel but the table-level ACL has to be done first.
15508 */
15514 }
15517 }
15520 }
15522 /*
15523 * Create the AS clause for a view or materialized view. The semicolon is
15524 * stripped because a materialized view must add a WITH NO DATA clause.
15525 *
15526 * This returns a new buffer which must be freed by the caller.
15527 */
15528 static PQExpBuffer
15530 {
15536 /* Fetch the view definition */
15544 {
15548 else
15551 }
15559 /* Strip off the trailing semicolon so that other things may follow. */
15567 }
15569 /*
15570 * Create a dummy AS clause for a view. This is used when the real view
15571 * definition has to be postponed because of circular dependencies.
15572 * We must duplicate the view's external properties -- column names and types
15573 * (including collation) -- so that it works for subsequent references.
15574 *
15575 * This returns a new buffer which must be freed by the caller.
15576 */
15577 static PQExpBuffer
15579 {
15586 {
15593 /*
15594 * Must add collation if not default for the type, because CREATE OR
15595 * REPLACE VIEW won't change it
15596 */
15598 {
15605 }
15608 }
15611 }
15613 /*
15614 * dumpTableSchema
15615 * write the declaration (not data) of one user-defined table or view
15616 */
15617 static void
15619 {
15631 k;
15633 /* We had better have loaded per-column details about this table */
15641 qrelname);
15646 /* Is it a table or a view? */
15648 {
15649 PQExpBuffer result;
15651 /*
15652 * Note: keep this code in sync with the is_view case in dumpRule()
15653 */
15667 else
15668 {
15670 {
15674 }
15676 }
15683 }
15684 else
15685 {
15691 /*
15692 * Set reltypename, and collect any relkind-specific data that we
15693 * didn't fetch during getTables().
15694 */
15696 {
15698 {
15704 /* retrieve partition key definition */
15713 }
15715 {
15723 /* retrieve name of foreign server and generic options */
15725 "SELECT fs.srvname, "
15726 "pg_catalog.array_to_string(ARRAY("
15727 "SELECT pg_catalog.quote_ident(option_name) || "
15728 "' ' || pg_catalog.quote_literal(option_value) "
15729 "FROM pg_catalog.pg_options_to_table(ftoptions) "
15730 "ORDER BY option_name"
15732 "FROM pg_catalog.pg_foreign_table ft "
15733 "JOIN pg_catalog.pg_foreign_server fs "
15734 "ON (fs.oid = ft.ftserver) "
15747 }
15754 }
15768 reltypename,
15769 qualrelname);
15771 /*
15772 * Attach to type, if reloftype; except in case of a binary upgrade,
15773 * we dump the table normally and attach it to the type afterward.
15774 */
15778 zeroIsError));
15781 {
15782 /* Dump the attributes */
15785 {
15786 /*
15787 * Normally, dump if it's locally defined in this table, and
15788 * not dropped. But for binary upgrade, we'll dump all the
15789 * columns, and then fix up the dropped and nonlocal cases
15790 * below.
15791 */
15793 {
15797 /*
15798 * Default value --- suppress if to be printed separately
15799 * or not at all.
15800 */
15805 /*
15806 * Not Null constraint --- suppress unless it is locally
15807 * defined, except if partition, or in binary-upgrade case
15808 * where that won't work.
15809 */
15810 print_notnull =
15815 /*
15816 * Skip column if fully defined by reloftype, except in
15817 * binary upgrade
15818 */
15824 /* Format properly if not first attr */
15827 else
15830 actual_atts++;
15832 /* Attribute name */
15836 {
15837 /*
15838 * ALTER TABLE DROP COLUMN clears
15839 * pg_attribute.atttypid, so we will not have gotten a
15840 * valid type name; insert INTEGER as a stopgap. We'll
15841 * clean things up later.
15842 */
15844 /* and skip to the next column */
15846 }
15848 /*
15849 * Attribute type; print it except when creating a typed
15850 * table ('OF type_name'), but in binary-upgrade mode,
15851 * print it in that case too.
15852 */
15854 {
15857 }
15860 {
15864 else
15867 }
15871 {
15874 else
15880 }
15882 /* Add collation if not default for the type */
15884 {
15891 }
15892 }
15893 }
15895 /*
15896 * Add non-inherited CHECK constraints, if any.
15897 *
15898 * For partitions, we need to include check constraints even if
15899 * they're not defined locally, because the ALTER TABLE ATTACH
15900 * PARTITION that we'll emit later expects the constraint to be
15901 * there. (No need to fix conislocal: ATTACH PARTITION does that)
15902 */
15904 {
15913 else
15920 actual_atts++;
15921 }
15926 {
15927 /*
15928 * No attributes? we must have a parenthesized attribute list,
15929 * even though empty, when not using the OF TYPE syntax.
15930 */
15932 }
15934 /*
15935 * Emit the INHERITS clause (not for partitions), except in
15936 * binary-upgrade mode.
15937 */
15940 {
15943 {
15949 }
15951 }
15958 }
15962 {
15967 {
15970 }
15972 {
15976 fout);
15977 }
15979 }
15981 /* Dump generic options if any */
15985 /*
15986 * For materialized views, create the AS clause just like a view. At
15987 * this point, we always mark the view as not populated.
15988 */
15990 {
15991 PQExpBuffer result;
15997 }
15998 else
16001 /* Materialized views can depend on extensions */
16006 qualrelname);
16008 /*
16009 * in binary upgrade mode, update the catalog with any missing values
16010 * that might be present.
16011 */
16013 {
16015 {
16017 {
16027 }
16028 }
16029 }
16031 /*
16032 * To create binary-compatible heap files, we have to ensure the same
16033 * physical column order, including dropped columns, as in the
16034 * original. Therefore, we create dropped columns above and drop them
16035 * here, also updating their attlen/attalign values so that the
16036 * dropped column can be skipped properly. (We do not bother with
16037 * restoring the original attbyval setting.) Also, inheritance
16038 * relationships are set up by doing ALTER TABLE INHERIT rather than
16039 * using an INHERITS clause --- the latter would possibly mess up the
16040 * column order. That also means we have to take care about setting
16041 * attislocal correctly, plus fix up any inherited CHECK constraints.
16042 * Analogously, we set up typed tables using ALTER TABLE / OF here.
16043 *
16044 * We process foreign and partitioned tables here, even though they
16045 * lack heap storage, because they can participate in inheritance
16046 * relationships and we want this stuff to be consistent across the
16047 * inheritance tree. We can exclude indexes, toast tables, sequences
16048 * and matviews, even though they have storage, because we don't
16049 * support altering or dropping columns in them, nor can they be part
16050 * of inheritance trees.
16051 */
16056 {
16058 {
16060 {
16063 "SET attlen = %d, "
16076 qualrelname);
16077 else
16079 qualrelname);
16082 }
16084 {
16094 /*
16095 * If a not-null constraint comes from inheritance, reset
16096 * conislocal. The inhcount is fixed later.
16097 */
16102 {
16111 }
16112 }
16113 }
16115 /*
16116 * Add inherited CHECK constraints, if any.
16117 *
16118 * For partitions, they were already dumped, and conislocal
16119 * doesn't need fixing.
16120 */
16122 {
16140 }
16143 {
16146 {
16150 qualrelname,
16152 }
16153 }
16156 {
16159 qualrelname,
16161 zeroIsError));
16162 }
16163 }
16165 /*
16166 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
16167 * relminmxid of all vacuumable relations. (While vacuum.c processes
16168 * TOAST tables semi-independently, here we see them only as children
16169 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
16170 * child toast table is handled below.)
16171 */
16175 {
16185 {
16186 /*
16187 * The toast table will have the same OID at restore, so we
16188 * can safely target it by OID.
16189 */
16190 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
16196 }
16197 }
16199 /*
16200 * In binary_upgrade mode, restore matviews' populated status by
16201 * poking pg_class directly. This is pretty ugly, but we can't use
16202 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
16203 * matview is not populated even though this matview is; in any case,
16204 * we want to transfer the matview's heap storage, not run REFRESH.
16205 */
16208 {
16215 }
16217 /*
16218 * Dump additional per-column properties that we can't handle in the
16219 * main CREATE TABLE command.
16220 */
16222 {
16223 /* None of this applies to dropped columns */
16227 /*
16228 * If we didn't dump the column definition explicitly above, and
16229 * it is not-null and did not inherit that property from a parent,
16230 * we have to mark it separately.
16231 */
16235 {
16236 /* No constraint name desired? */
16242 else
16248 }
16250 /*
16251 * Dump per-column statistics information. We only issue an ALTER
16252 * TABLE statement if the attstattarget entry for this column is
16253 * non-negative (i.e. it's not the default value)
16254 */
16261 /*
16262 * Dump per-column storage information. The statement is only
16263 * dumped if the storage has been changed from the type's default.
16264 */
16266 {
16268 {
16283 }
16285 /*
16286 * Only dump the statement if it's a storage type we recognize
16287 */
16292 storage);
16293 }
16295 /*
16296 * Dump per-column compression, if it's been set.
16297 */
16299 {
16303 {
16313 }
16319 cmname);
16320 }
16322 /*
16323 * Dump per-column attributes.
16324 */
16331 /*
16332 * Dump per-column fdw options.
16333 */
16340 qualrelname,
16348 }
16350 /*
16351 * dump properties we only have ALTER TABLE syntax for
16352 */
16357 {
16359 {
16360 /* nothing to do, will be set when the index is dumped */
16361 }
16363 {
16365 qualrelname);
16366 }
16368 {
16370 qualrelname);
16371 }
16372 }
16376 qualrelname);
16384 {
16388 /*
16389 * _selectTablespace() relies on tablespace-enabled objects in the
16390 * default tablespace to have a tablespace of "" (empty string) versus
16391 * non-tablespace-enabled objects to have a tablespace of NULL.
16392 * getTables() sets tbinfo->reltablespace to "" for the default
16393 * tablespace (not NULL).
16394 */
16412 }
16414 /* Dump Table Comments */
16418 /* Dump Table Security Labels */
16422 /* Dump comments on inlined table constraints */
16424 {
16432 }
16438 }
16440 /*
16441 * dumpTableAttach
16442 * write to fout the commands to attach a child partition
16443 *
16444 * Child partitions are always made by creating them separately
16445 * and then using ATTACH PARTITION, rather than using
16446 * CREATE TABLE ... PARTITION OF. This is important for preserving
16447 * any possible discrepancy in column layout, to allow assigning the
16448 * correct tablespace if different, and so that it's possible to restore
16449 * a partition without restoring its parent. (You'll get an error from
16450 * the ATTACH PARTITION command, but that can be ignored, or skipped
16451 * using "pg_restore -L" if you prefer.) The last point motivates
16452 * treating ATTACH PARTITION as a completely separate ArchiveEntry
16453 * rather than emitting it within the child partition's ArchiveEntry.
16454 */
16455 static void
16457 {
16459 PQExpBuffer q;
16463 /* Do nothing in data-only dump */
16470 {
16471 /* Set up query for partbound details */
16476 "SELECT pg_get_expr(c.relpartbound, c.oid) "
16477 "FROM pg_class c "
16483 }
16492 /* Perform ALTER TABLE on the parent */
16499 partbound);
16501 /*
16502 * There is no point in creating a drop query as the drop is done by table
16503 * drop. (If you think to change this, see also _printTocEntry().)
16504 * Although this object doesn't really have ownership as such, set the
16505 * owner field anyway to ensure that the command is run by the correct
16506 * role at restore time.
16507 */
16518 }
16520 /*
16521 * dumpAttrDef --- dump an attribute's default-value declaration
16522 */
16523 static void
16525 {
16529 PQExpBuffer q;
16530 PQExpBuffer delq;
16535 /* Do nothing in data-only dump */
16539 /* Skip if not "separate"; it was dumped in the table's definition */
16575 }
16577 /*
16578 * getAttrName: extract the correct name for an attribute
16579 *
16580 * The array tblInfo->attnames[] only provides names of user attributes;
16581 * if a system attribute number is supplied, we have to fake it.
16582 * We also do a little bit of bounds checking for safety's sake.
16583 */
16586 {
16590 {
16603 }
16607 }
16609 /*
16610 * dumpIndex
16611 * write out to fout a user-defined index
16612 */
16613 static void
16615 {
16619 PQExpBuffer q;
16620 PQExpBuffer delq;
16624 /* Do nothing in data-only dump */
16634 /*
16635 * If there's an associated constraint, don't dump the index per se, but
16636 * do dump any comment for it. (This is safe because dependency ordering
16637 * will have ensured the constraint is emitted first.) Note that the
16638 * emitted comment has to be shown as depending on the constraint, not the
16639 * index, in such cases.
16640 */
16642 {
16654 /* Plain secondary index */
16657 /*
16658 * Append ALTER TABLE commands as needed to set properties that we
16659 * only have ALTER TABLE syntax for. Keep this in sync with the
16660 * similar code in dumpConstraint!
16661 */
16663 /* If the index is clustered, we need to record that. */
16665 {
16668 /* index name is not qualified in this syntax */
16670 qindxname);
16671 }
16673 /*
16674 * If the index has any statistics on some of its columns, generate
16675 * the associated ALTER INDEX queries.
16676 */
16678 {
16689 {
16692 /*
16693 * Note that this is a column number, so no quotes should be
16694 * used.
16695 */
16700 }
16701 }
16703 /* Indexes can depend on extensions */
16708 /* If the index defines identity, we need to record that. */
16710 {
16713 /* index name is not qualified in this syntax */
16715 qindxname);
16716 }
16733 }
16735 /* Dump Index Comments */
16748 }
16750 /*
16751 * dumpIndexAttach
16752 * write out to fout a partitioned-index attachment clause
16753 */
16754 static void
16756 {
16757 /* Do nothing in data-only dump */
16762 {
16770 /*
16771 * There is no point in creating a drop query as the drop is done by
16772 * index drop. (If you think to change this, see also
16773 * _printTocEntry().) Although this object doesn't really have
16774 * ownership as such, set the owner field anyway to ensure that the
16775 * command is run by the correct role at restore time.
16776 */
16786 }
16787 }
16789 /*
16790 * dumpStatisticsExt
16791 * write out to fout an extended statistics object
16792 */
16793 static void
16795 {
16797 PQExpBuffer q;
16798 PQExpBuffer delq;
16799 PQExpBuffer query;
16804 /* Do nothing in data-only dump */
16822 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
16825 /*
16826 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
16827 * for this statistics object is non-negative (i.e. it's not the default
16828 * value).
16829 */
16831 {
16836 }
16852 /* Dump Statistics Comments */
16865 }
16867 /*
16868 * dumpConstraint
16869 * write out to fout a user-defined constraint
16870 */
16871 static void
16873 {
16876 PQExpBuffer q;
16877 PQExpBuffer delq;
16881 /* Do nothing in data-only dump */
16894 {
16895 /* Index-related constraint */
16915 {
16916 /* pg_get_constraintdef should have provided everything */
16918 }
16919 else
16920 {
16924 /*
16925 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
16926 * indexes. Being able to create this was fixed, but we need to
16927 * make the index distinct in order to be able to restore the
16928 * dump.
16929 */
16934 {
16945 }
16951 {
16962 }
16967 {
16971 }
16974 {
16978 }
16981 }
16983 /*
16984 * Append ALTER TABLE commands as needed to set properties that we
16985 * only have ALTER TABLE syntax for. Keep this in sync with the
16986 * similar code in dumpIndex!
16987 */
16989 /* Drop any not-null constraints that were added to support the PK */
16997 /* If the index is clustered, we need to record that. */
16999 {
17002 /* index name is not qualified in this syntax */
17005 }
17007 /* If the index defines identity, we need to record that. */
17009 {
17012 /* index name is not qualified in this syntax */
17015 }
17017 /* Indexes can depend on extensions */
17039 }
17041 {
17044 /*
17045 * Foreign keys on partitioned tables are always declared as
17046 * inheriting to partitions; for all other cases, emit them as
17047 * applying ONLY directly to the named table, because that's how they
17048 * work for regular inherited tables.
17049 */
17052 /*
17053 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
17054 * current table data is not processed
17055 */
17078 }
17080 {
17081 /* CHECK constraint on a table */
17083 /* Ignore if not to be dumped separately, or if it was inherited */
17085 {
17086 /* not ONLY since we want it to propagate to children */
17109 }
17110 }
17112 {
17113 /* CHECK constraint on a domain */
17116 /* Ignore if not to be dumped separately */
17118 {
17141 }
17142 }
17143 else
17144 {
17147 }
17149 /* Dump Constraint Comments --- only works for table constraints */
17157 }
17159 /*
17160 * dumpTableConstraintComment --- dump a constraint's comment if any
17161 *
17162 * This is split out because we need the function in two different places
17163 * depending on whether the constraint is dumped as part of CREATE TABLE
17164 * or as a separate ALTER command.
17165 */
17166 static void
17168 {
17187 }
17189 /*
17190 * dumpSequence
17191 * write the declaration (not data) of one user-defined sequence
17192 */
17193 static void
17195 {
17206 int64 default_minv,
17207 default_maxv;
17218 {
17220 "SELECT format_type(seqtypid, NULL), "
17221 "seqstart, seqincrement, "
17222 "seqmax, seqmin, "
17223 "seqcache, seqcycle "
17224 "FROM pg_catalog.pg_sequence "
17227 }
17228 else
17229 {
17230 /*
17231 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
17232 *
17233 * Note: it might seem that 'bigint' potentially needs to be
17234 * schema-qualified, but actually that's a keyword.
17235 */
17237 "SELECT 'bigint' AS sequence_type, "
17238 "start_value, increment_by, max_value, min_value, "
17241 }
17259 /* Calculate default limits for a sequence of this type */
17262 {
17265 }
17267 {
17270 }
17272 {
17275 }
17276 else
17277 {
17280 }
17282 /*
17283 * 64-bit strtol() isn't very portable, so convert the limits to strings
17284 * and compare that way.
17285 */
17289 /* Don't print minv/maxv if they match the respective default limit */
17295 /*
17296 * Identity sequences are not to be dropped separately.
17297 */
17299 {
17302 }
17307 {
17311 /*
17312 * In older PG versions a sequence will have a pg_type entry, but v14
17313 * and up don't use that, so don't attempt to preserve the type OID.
17314 */
17315 }
17318 {
17333 }
17334 else
17335 {
17344 }
17352 else
17357 else
17365 {
17373 }
17374 else
17377 /* binary_upgrade: no need to clear TOAST table oid */
17394 /*
17395 * If the sequence is owned by a table column, emit the ALTER for it as a
17396 * separate TOC entry immediately following the sequence's own entry. It's
17397 * OK to do this rather than using full sorting logic, because the
17398 * dependency that tells us it's owned will have forced the table to be
17399 * created first. We can't just include the ALTER in the TOC entry
17400 * because it will fail if we haven't reassigned the sequence owner to
17401 * match the table's owner.
17402 *
17403 * We need not schema-qualify the table reference because both sequence
17404 * and table must be in the same schema.
17405 */
17407 {
17415 {
17434 }
17435 }
17437 /* Dump Sequence Comments and Security Labels */
17453 }
17455 /*
17456 * dumpSequenceData
17457 * write the data of one user-defined sequence
17458 */
17459 static void
17461 {
17503 }
17505 /*
17506 * dumpTrigger
17507 * write the declaration of one user-defined table trigger
17508 */
17509 static void
17511 {
17514 PQExpBuffer query;
17515 PQExpBuffer delqry;
17516 PQExpBuffer trigprefix;
17517 PQExpBuffer trigidentity;
17525 /* Do nothing in data-only dump */
17542 {
17544 }
17545 else
17546 {
17548 {
17551 }
17552 else
17553 {
17556 }
17559 /* Trigger type */
17566 else
17571 {
17573 findx++;
17574 }
17576 {
17579 else
17581 findx++;
17582 }
17584 {
17587 else
17589 findx++;
17590 }
17592 {
17595 else
17597 findx++;
17598 }
17603 {
17605 {
17606 /* regclass output is already quoted */
17609 }
17615 else
17617 }
17621 else
17624 /* regproc output is already sufficiently quoted */
17632 {
17633 /* find the embedded null that terminates this trigger argument */
17637 {
17638 /* hm, not found before end of bytea value... */
17643 }
17649 }
17652 }
17654 /* Triggers can depend on extensions */
17660 {
17663 /*
17664 * Partition triggers only appear here because their 'tgenabled' flag
17665 * differs from its parent's. The trigger is created already, so
17666 * remove the CREATE and replace it with an ALTER. (Clear out the
17667 * DROP query too, so that pg_dump --create does not cause errors.)
17668 */
17675 {
17690 }
17693 }
17695 {
17700 {
17714 }
17717 }
17745 }
17747 /*
17748 * dumpEventTrigger
17749 * write the declaration of one user-defined event trigger
17750 */
17751 static void
17753 {
17755 PQExpBuffer query;
17756 PQExpBuffer delqry;
17759 /* Do nothing in data-only dump */
17774 {
17778 }
17785 {
17787 qevtname);
17789 {
17802 }
17804 }
17807 qevtname);
17830 }
17832 /*
17833 * dumpRule
17834 * Dump a rule
17835 */
17836 static void
17838 {
17842 PQExpBuffer query;
17843 PQExpBuffer cmd;
17844 PQExpBuffer delcmd;
17845 PQExpBuffer ruleprefix;
17850 /* Do nothing in data-only dump */
17854 /*
17855 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
17856 * we do not want to dump it as a separate object.
17857 */
17861 /*
17862 * If it's an ON SELECT rule, we want to print it as a view definition,
17863 * instead of a rule.
17864 */
17875 {
17876 PQExpBuffer result;
17878 /*
17879 * We need OR REPLACE here because we'll be replacing a dummy view.
17880 * Otherwise this should look largely like the regular view dump code.
17881 */
17885 {
17889 }
17897 }
17898 else
17899 {
17900 /* In the rule case, just print pg_get_ruledef's result verbatim */
17914 }
17916 /*
17917 * Add the command to alter the rules replication firing semantics if it
17918 * differs from the default.
17919 */
17921 {
17924 {
17937 }
17938 }
17941 {
17942 /*
17943 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
17944 * REPLACE VIEW to replace the rule with something with minimal
17945 * dependencies.
17946 */
17947 PQExpBuffer result;
17954 }
17955 else
17956 {
17961 }
17978 /* Dump rule comments */
17991 }
17993 /*
17994 * getExtensionMembership --- obtain extension membership data
17995 *
17996 * We need to identify objects that are extension members as soon as they're
17997 * loaded, so that we can correctly determine whether they need to be dumped.
17998 * Generally speaking, extension member objects will get marked as *not* to
17999 * be dumped, as they will be recreated by the single CREATE EXTENSION
18000 * command. However, in binary upgrade mode we still need to dump the members
18001 * individually.
18002 */
18003 void
18006 {
18007 PQExpBuffer query;
18010 i;
18012 i_objid,
18013 i_refobjid;
18016 /* Nothing to do if no extensions */
18022 /* refclassid constraint is redundant but may speed the search */
18024 "classid, objid, refobjid "
18025 "FROM pg_depend "
18026 "WHERE refclassid = 'pg_extension'::regclass "
18027 "AND deptype = 'e' "
18038 /*
18039 * Since we ordered the SELECT by referenced ID, we can expect that
18040 * multiple entries for the same extension will appear together; this
18041 * saves on searches.
18042 */
18046 {
18047 CatalogId objId;
18048 Oid extId;
18059 {
18060 /* shouldn't happen */
18063 }
18066 }
18071 }
18073 /*
18074 * processExtensionTables --- deal with extension configuration tables
18075 *
18076 * There are two parts to this process:
18077 *
18078 * 1. Identify and create dump records for extension configuration tables.
18079 *
18080 * Extensions can mark tables as "configuration", which means that the user
18081 * is able and expected to modify those tables after the extension has been
18082 * loaded. For these tables, we dump out only the data- the structure is
18083 * expected to be handled at CREATE EXTENSION time, including any indexes or
18084 * foreign keys, which brings us to-
18085 *
18086 * 2. Record FK dependencies between configuration tables.
18087 *
18088 * Due to the FKs being created at CREATE EXTENSION time and therefore before
18089 * the data is loaded, we have to work out what the best order for reloading
18090 * the data is, to avoid FK violations when the tables are restored. This is
18091 * not perfect- we can't handle circular dependencies and if any exist they
18092 * will cause an invalid dump to be produced (though at least all of the data
18093 * is included for a user to manually restore). This is currently documented
18094 * but perhaps we can provide a better solution in the future.
18095 */
18096 void
18099 {
18101 PQExpBuffer query;
18104 i;
18106 i_confrelid;
18108 /* Nothing to do if no extensions */
18112 /*
18113 * Identify extension configuration tables and create TableDataInfo
18114 * objects for them, ensuring their data will be dumped even though the
18115 * tables themselves won't be.
18116 *
18117 * Note that we create TableDataInfo objects even in schemaOnly mode, ie,
18118 * user data in a configuration table is treated like schema data. This
18119 * seems appropriate since system data in a config table would get
18120 * reloaded by CREATE EXTENSION. If the extension is not listed in the
18121 * list of extensions to be included, none of its data is dumped.
18122 */
18124 {
18133 /*
18134 * Check if this extension is listed as to include in the dump. If
18135 * not, any table data associated with it is discarded.
18136 */
18143 {
18154 {
18164 /*
18165 * Tables of not-to-be-dumped extensions shouldn't be dumped
18166 * unless the table or its schema is explicitly included
18167 */
18169 {
18170 /* check table explicitly requested */
18173 configtbloid))
18176 /* check table's schema explicitly requested */
18178 DUMP_COMPONENT_DATA)
18180 }
18182 /* check table excluded by an exclusion switch */
18185 configtbloid))
18188 /* check schema excluded by an exclusion switch */
18194 {
18197 {
18200 }
18201 }
18202 }
18203 }
18208 }
18210 /*
18211 * Now that all the TableDataInfo objects have been created for all the
18212 * extensions, check their FK dependencies and register them to try and
18213 * dump the data out in an order that they can be restored in.
18214 *
18215 * Note that this is not a problem for user tables as their FKs are
18216 * recreated after the data has been loaded.
18217 */
18222 "SELECT conrelid, confrelid "
18223 "FROM pg_constraint "
18224 "JOIN pg_depend ON (objid = confrelid) "
18225 "WHERE contype = 'f' "
18226 "AND refclassid = 'pg_extension'::regclass "
18235 /* Now get the dependencies and register them */
18237 {
18238 Oid conrelid,
18239 confrelid;
18254 /*
18255 * Make referencing TABLE_DATA object depend on the referenced table's
18256 * TABLE_DATA object.
18257 */
18260 }
18263 }
18265 /*
18266 * getDependencies --- obtain available dependency data
18267 */
18268 static void
18270 {
18271 PQExpBuffer query;
18274 i;
18276 i_objid,
18277 i_refclassid,
18278 i_refobjid,
18279 i_deptype;
18287 /*
18288 * Messy query to collect the dependency data we need. Note that we
18289 * ignore the sub-object column, so that dependencies of or on a column
18290 * look the same as dependencies of or on a whole table.
18291 *
18292 * PIN dependencies aren't interesting, and EXTENSION dependencies were
18293 * already processed by getExtensionMembership.
18294 */
18296 "classid, objid, refclassid, refobjid, deptype "
18297 "FROM pg_depend "
18300 /*
18301 * Since we don't treat pg_amop entries as separate DumpableObjects, we
18302 * have to translate their dependencies into dependencies of their parent
18303 * opfamily. Ignore internal dependencies though, as those will point to
18304 * their parent opclass, which we needn't consider here (and if we did,
18305 * it'd just result in circular dependencies). Also, "loose" opfamily
18306 * entries will have dependencies on their parent opfamily, which we
18307 * should drop since they'd likewise become useless self-dependencies.
18308 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
18309 */
18311 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
18312 "FROM pg_depend d, pg_amop o "
18313 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18314 "classid = 'pg_amop'::regclass AND objid = o.oid "
18317 /* Likewise for pg_amproc entries */
18319 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
18320 "FROM pg_depend d, pg_amproc p "
18321 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18322 "classid = 'pg_amproc'::regclass AND objid = p.oid "
18325 /* Sort the output for efficiency below */
18338 /*
18339 * Since we ordered the SELECT by referencing ID, we can expect that
18340 * multiple entries for the same object will appear together; this saves
18341 * on searches.
18342 */
18346 {
18347 CatalogId objId;
18348 CatalogId refobjId;
18362 /*
18363 * Failure to find objects mentioned in pg_depend is not unexpected,
18364 * since for example we don't collect info about TOAST tables.
18365 */
18367 {
18368 #ifdef NOT_USED
18371 #endif
18373 }
18378 {
18379 #ifdef NOT_USED
18382 #endif
18384 }
18386 /*
18387 * For 'x' dependencies, mark the object for later; we still add the
18388 * normal dependency, for possible ordering purposes. Currently
18389 * pg_dump_sort.c knows to put extensions ahead of all object types
18390 * that could possibly depend on them, but this is safer.
18391 */
18395 /*
18396 * Ordinarily, table rowtypes have implicit dependencies on their
18397 * tables. However, for a composite type the implicit dependency goes
18398 * the other way in pg_depend; which is the right thing for DROP but
18399 * it doesn't produce the dependency ordering we need. So in that one
18400 * case, we reverse the direction of the dependency.
18401 */
18406 else
18407 /* normal case */
18409 }
18414 }
18417 /*
18418 * createBoundaryObjects - create dummy DumpableObjects to represent
18419 * dump section boundaries.
18420 */
18423 {
18439 }
18441 /*
18442 * addBoundaryDependencies - add dependencies as needed to enforce the dump
18443 * section boundaries.
18444 */
18445 static void
18448 {
18454 {
18457 /*
18458 * The classification of object types here must match the SECTION_xxx
18459 * values assigned during subsequent ArchiveEntry calls!
18460 */
18462 {
18489 /* Pre-data objects: must come before the pre-data boundary */
18495 /* Data objects: must come between the boundaries */
18511 /* Post-data objects: must come after the post-data boundary */
18515 /* Rules are post-data, but only if dumped separately */
18521 /* Constraints are post-data, but only if dumped separately */
18526 /* nothing to do */
18529 /* must come after the pre-data boundary */
18532 }
18533 }
18534 }
18537 /*
18538 * BuildArchiveDependencies - create dependency data for archive TOC entries
18539 *
18540 * The raw dependency data obtained by getDependencies() is not terribly
18541 * useful in an archive dump, because in many cases there are dependency
18542 * chains linking through objects that don't appear explicitly in the dump.
18543 * For example, a view will depend on its _RETURN rule while the _RETURN rule
18544 * will depend on other objects --- but the rule will not appear as a separate
18545 * object in the dump. We need to adjust the view's dependencies to include
18546 * whatever the rule depends on that is included in the dump.
18547 *
18548 * Just to make things more complicated, there are also "special" dependencies
18549 * such as the dependency of a TABLE DATA item on its TABLE, which we must
18550 * not rearrange because pg_restore knows that TABLE DATA only depends on
18551 * its table. In these cases we must leave the dependencies strictly as-is
18552 * even if they refer to not-to-be-dumped objects.
18553 *
18554 * To handle this, the convention is that "special" dependencies are created
18555 * during ArchiveEntry calls, and an archive TOC item that has any such
18556 * entries will not be touched here. Otherwise, we recursively search the
18557 * DumpableObject data structures to build the correct dependencies for each
18558 * archive TOC item.
18559 */
18560 static void
18562 {
18566 /* Scan all TOC entries in the archive */
18568 {
18574 /* No need to process entries that will not be dumped */
18577 /* Ignore entries that already have "special" dependencies */
18580 /* Otherwise, look up the item's original DumpableObject, if any */
18584 /* No work if it has no dependencies */
18587 /* Set up work array */
18591 /* Recursively find all dumpable dependencies */
18594 /* And save 'em ... */
18596 {
18601 }
18602 else
18604 }
18605 }
18607 /* Recursive search subroutine for BuildArchiveDependencies */
18608 static void
18611 {
18614 /*
18615 * Ignore section boundary objects: if we search through them, we'll
18616 * report lots of bogus dependencies.
18617 */
18623 {
18627 {
18628 /* Object will be dumped, so just reference it as a dependency */
18630 {
18634 }
18637 }
18638 else
18639 {
18640 /*
18641 * Object will not be dumped, so recursively consider its deps. We
18642 * rely on the assumption that sortDumpableObjects already broke
18643 * any dependency loops, else we might recurse infinitely.
18644 */
18650 }
18651 }
18652 }
18655 /*
18656 * getFormattedTypeName - retrieve a nicely-formatted type name for the
18657 * given type OID.
18658 *
18659 * This does not guarantee to schema-qualify the output, so it should not
18660 * be used to create the target object name for CREATE or ALTER commands.
18661 *
18662 * Note that the result is cached and must not be freed by the caller.
18663 */
18666 {
18669 PQExpBuffer query;
18673 {
18678 }
18680 /* see if we have the result cached in the type's TypeInfo record */
18687 oid);
18691 /* result of format_type is already quoted */
18697 /*
18698 * Cache the result for re-use in later requests, if possible. If we
18699 * don't have a TypeInfo for the type, the string will be leaked once the
18700 * caller is done with it ... but that case really should not happen, so
18701 * leaking if it does seems acceptable.
18702 */
18707 }
18709 /*
18710 * Return a column list clause for the given relation.
18711 *
18712 * Special case: if there are no undropped columns in the relation, return
18713 * "", not an invalid "()" column list.
18714 */
18717 {
18728 {
18737 }
18744 }
18746 /*
18747 * Check if a reloptions array is nonempty.
18748 */
18749 static bool
18751 {
18752 /* Don't want to print it if it's just "{}" */
18754 }
18756 /*
18757 * Format a reloptions array and append it to the given buffer.
18758 *
18759 * "prefix" is prepended to the option names; typically it's "" or "toast.".
18760 */
18761 static void
18764 {
18771 }