| blob | 1ac09fa161da77b35886c273d29076fc4832285d |
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-2019, 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
70 {
78 {
87 {
94 /* global decls */
97 /* subquery used to convert user ID (eg, datdba) to user name */
100 /*
101 * For 8.0 and earlier servers, pulled from pg_database, for 8.1+ we use
102 * FirstNormalObjectId - 1.
103 */
106 /* The specified names/patterns should to match at least one entity */
109 /*
110 * Object inclusion/exclusion lists
111 *
112 * The string lists record the patterns given by command-line switches,
113 * which we then convert to lists of OIDs of matching objects.
114 */
130 /* placeholders for the delimiters for comments */
136 /* override for standard extra_float_digits setting */
140 /*
141 * The default number of rows per INSERT when
142 * --inserts is specified without --rows-per-insert
143 */
144 #define DUMP_DEFAULT_ROWS_PER_INSERT 1
146 /*
147 * Macro for producing quoted, schema-qualified name of a dumpable object.
148 */
149 #define fmtQualifiedDumpable(obj) \
150 fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
151 (obj)->dobj.name)
279 PQExpBuffer upgrade_buffer,
280 Oid pg_type_oid,
285 PQExpBuffer upgrade_buffer,
303 int
305 {
328 ArchiveMode archiveMode;
363 /*
364 * the following options don't have an equivalent short option letter
365 */
397 };
403 /*
404 * Initialize what we need for parallel execution, especially for thread
405 * support on Windows.
406 */
416 {
418 {
421 }
423 {
426 }
427 }
433 {
435 {
498 /* no-op, still accepted for backwards compatibility */
542 {
545 }
549 /* This covers the long options. */
580 {
583 }
588 /*
589 * dump_inserts also stores --rows-per-insert, careful not to
590 * overwrite that.
591 */
603 {
607 }
614 }
615 }
617 /*
618 * Non-option argument specifies database name as long as it wasn't
619 * already specified with -d / --dbname
620 */
624 /* Complain if any arguments remain */
626 {
630 progname);
632 }
634 /* --column-inserts implies --inserts */
638 /*
639 * Binary upgrade mode implies dumping sequence data even in schema-only
640 * mode. This is not exposed as a separate option, but kept separate
641 * internally for clarity.
642 */
647 {
650 }
653 {
656 }
661 /*
662 * --inserts are already implied above if --column-inserts or
663 * --rows-per-insert were specified.
664 */
666 fatal("option --on-conflict-do-nothing requires option --inserts, --rows-per-insert, or --column-inserts");
668 /* Identify archive format to emit */
671 /* archiveFormat specific setup */
675 /* Custom and directory formats are compressed by default, others not */
677 {
678 #ifdef HAVE_LIBZ
681 else
682 #endif
684 }
686 #ifndef HAVE_LIBZ
688 pg_log_warning("requested compression not available in this installation -- archive will be uncompressed");
690 #endif
692 /*
693 * If emitting an archive format, we always want to emit a DATABASE item,
694 * in case --create is specified at pg_restore time.
695 */
699 /*
700 * On Windows we can only have at most MAXIMUM_WAIT_OBJECTS (= 64 usually)
701 * parallel jobs because that's the maximum limit for the
702 * WaitForMultipleObjects() call.
703 */
705 #ifdef WIN32
707 #endif
708 )
711 /* Parallel backup only in the directory archive format so far */
715 /* Open the output file */
719 /* Make dump options accessible right away */
722 /* Register the cleanup hook */
725 /* Let the archiver know how noisy to be */
729 /*
730 * We allow the server to be back to 8.0, and up to any minor release of
731 * our own major version. (See also version check in pg_dumpall.c.)
732 */
738 /*
739 * Open the database using the Archiver, so it knows about it. Errors mean
740 * death.
741 */
745 /*
746 * Disable security label support if server version < v9.1.x (prevents
747 * access to nonexistent pg_seclabel catalog)
748 */
752 /*
753 * On hot standbys, never try to dump unlogged table data, since it will
754 * just throw an error.
755 */
759 /* Select the appropriate subquery to convert user IDs to names */
762 else
765 /* check the version for the synchronized snapshots feature */
772 /* check the version when a snapshot is explicitly specified by user */
776 /*
777 * Find the last built-in OID, if needed (prior to 8.1)
778 *
779 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
780 */
783 else
788 /* Expand schema selection patterns into OID lists */
790 {
793 strict_names);
796 }
800 /* non-matching exclusion patterns aren't an error */
802 /* Expand table selection patterns into OID lists */
804 {
807 strict_names);
810 }
819 /* non-matching exclusion patterns aren't an error */
821 /*
822 * Dumping blobs is the default for dumps where an inclusion switch is not
823 * used (an "include everything" dump). -B can be used to exclude blobs
824 * from those dumps. -b can be used to include blobs even when an
825 * inclusion switch is used.
826 *
827 * -s means "schema only" and blobs are data, not schema, so we never
828 * include blobs when -s is used.
829 */
833 /*
834 * Now scan the database and create DumpableObject structs for all the
835 * objects we intend to dump.
836 */
843 {
848 }
853 /*
854 * In binary-upgrade mode, we do not have to worry about the actual blob
855 * data or the associated metadata that resides in the pg_largeobject and
856 * pg_largeobject_metadata tables, respectively.
857 *
858 * However, we do need to collect blob information as there may be
859 * comments or other information on blobs that we do need to dump out.
860 */
864 /*
865 * Collect dependency data to assist in ordering the objects.
866 */
869 /* Lastly, create dummy objects to represent the section boundaries */
872 /* Get pointers to all the known DumpableObjects */
875 /*
876 * Add dummy dependencies to enforce the dump section ordering.
877 */
880 /*
881 * Sort the objects into a safe dump order (no forward references).
882 *
883 * We rely on dependency information to help us determine a safe order, so
884 * the initial sort is mostly for cosmetic purposes: we sort by name to
885 * ensure that logically identical schemas will dump identically.
886 */
892 /*
893 * Create archive TOC entries for all the objects to be dumped, in a safe
894 * order.
895 */
897 /* First the special ENCODING, STDSTRINGS, and SEARCHPATH entries. */
902 /* The database items are always next, unless we don't want them at all */
906 /* Now the rearrangeable objects. */
910 /*
911 * Set up options info to ensure we dump what we want.
912 */
916 /* if you change this list, see dumpOptionsFromRestoreOptions */
949 else
956 /* Mark which entries should be output */
959 /*
960 * The archive's TOC entries are now marked as to which ones will actually
961 * be output, so we can set up their dependency lists properly. This isn't
962 * necessary for plain-text output, though.
963 */
967 /*
968 * And finally we can do the actual output.
969 *
970 * Note: for non-plain-text output formats, the output file is written
971 * inside CloseArchive(). This is, um, bizarre; but not worth changing
972 * right now.
973 */
980 }
983 static void
985 {
1033 printf(_(" --no-synchronized-snapshots do not use synchronized snapshots in parallel jobs\n"));
1060 }
1062 static void
1065 {
1072 /*
1073 * Set the client encoding if requested.
1074 */
1076 {
1079 dumpencoding);
1080 }
1082 /*
1083 * Get the active encoding and the standard_conforming_strings setting, so
1084 * we know how to escape strings.
1085 */
1091 /*
1092 * Set the role if requested. In a parallel dump worker, we'll be passed
1093 * use_role == NULL, but AH->use_role is already set (if user specified it
1094 * originally) and we should use that.
1095 */
1099 /* Set the role if requested */
1101 {
1108 /* save it for possible later use by parallel workers */
1111 }
1113 /* Set the datestyle to ISO to ensure the dump's portability */
1116 /* Likewise, avoid using sql_standard intervalstyle */
1120 /*
1121 * Use an explicitly specified extra_float_digits if it has been provided.
1122 * Otherwise, set extra_float_digits so that we can dump float data
1123 * exactly (given correctly implemented float I/O code, anyway).
1124 */
1126 {
1130 extra_float_digits);
1133 }
1136 else
1139 /*
1140 * If synchronized scanning is supported, disable it, to prevent
1141 * unpredictable changes in row ordering across a dump and reload.
1142 */
1146 /*
1147 * Disable timeouts if supported.
1148 */
1155 /*
1156 * Quote all identifiers, if requested.
1157 */
1161 /*
1162 * Adjust row-security mode, if supported.
1163 */
1165 {
1168 else
1170 }
1172 /*
1173 * Start transaction-snapshot mode transaction to dump consistent data.
1174 */
1177 {
1178 /*
1179 * To support the combination of serializable_deferrable with the jobs
1180 * option we use REPEATABLE READ for the worker connections that are
1181 * passed a snapshot. As long as the snapshot is acquired in a
1182 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1183 * REPEATABLE READ transaction provides the appropriate integrity
1184 * guarantees. This is a kluge, but safe for back-patching.
1185 */
1188 "SET TRANSACTION ISOLATION LEVEL "
1190 else
1192 "SET TRANSACTION ISOLATION LEVEL "
1194 }
1195 else
1196 {
1198 "SET TRANSACTION ISOLATION LEVEL "
1200 }
1202 /*
1203 * If user specified a snapshot to use, select that. In a parallel dump
1204 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1205 * is already set (if the server can handle it) and we should use that.
1206 */
1211 {
1218 }
1222 {
1230 }
1231 }
1233 /* Set up connection for a parallel worker process */
1234 static void
1236 {
1237 /*
1238 * We want to re-select all the same values the master connection is
1239 * using. We'll have inherited directly-usable values in
1240 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1241 * inherited encoding value back to a string to pass to setup_connection.
1242 */
1245 NULL,
1246 NULL);
1247 }
1251 {
1261 }
1263 static ArchiveFormat
1265 {
1266 ArchiveFormat archiveFormat;
1271 {
1272 /* This is used by pg_dumpall, and is not documented */
1275 }
1292 else
1295 }
1297 /*
1298 * Find the OIDs of all schemas matching the given list of patterns,
1299 * and append them to the given OID list.
1300 */
1301 static void
1306 {
1307 PQExpBuffer query;
1317 /*
1318 * The loop below runs multiple SELECTs might sometimes result in
1319 * duplicate entries in the OID list, but we don't care.
1320 */
1323 {
1334 {
1336 }
1340 }
1343 }
1345 /*
1346 * Find the OIDs of all tables matching the given list of patterns,
1347 * and append them to the given OID list. See also expand_dbname_patterns()
1348 * in pg_dumpall.c
1349 */
1350 static void
1354 {
1355 PQExpBuffer query;
1365 /*
1366 * this might sometimes result in duplicate entries in the OID list, but
1367 * we don't care.
1368 */
1371 {
1372 /*
1373 * Query must remain ABSOLUTELY devoid of unqualified names. This
1374 * would be unnecessary given a pg_table_is_visible() variant taking a
1375 * search_path argument.
1376 */
1378 "SELECT c.oid"
1386 RELKIND_PARTITIONED_TABLE);
1394 ALWAYS_SECURE_SEARCH_PATH_SQL));
1399 {
1401 }
1405 }
1408 }
1410 /*
1411 * checkExtensionMembership
1412 * Determine whether object is an extension member, and if so,
1413 * record an appropriate dependency and set the object's dump flag.
1414 *
1415 * It's important to call this for each object that could be an extension
1416 * member. Generally, we integrate this with determining the object's
1417 * to-be-dumped-ness, since extension membership overrides other rules for that.
1418 *
1419 * Returns true if object is an extension member, else false.
1420 */
1421 static bool
1423 {
1431 /* Record dependency so that getDependencies needn't deal with that */
1434 /*
1435 * In 9.6 and above, mark the member object to have any non-initial ACLs
1436 * dumped. (Any initial ACLs will be removed later, using data from
1437 * pg_init_privs, so that we'll dump only the delta from the extension's
1438 * initial setup.)
1439 *
1440 * Prior to 9.6, we do not include any extension member components.
1441 *
1442 * In binary upgrades, we still dump all components of the members
1443 * individually, since the idea is to exactly reproduce the database
1444 * contents rather than replace the extension contents with something
1445 * different.
1446 *
1447 * Note: it might be interesting someday to implement storage and delta
1448 * dumping of extension members' RLS policies and/or security labels.
1449 * However there is a pitfall for RLS policies: trying to dump them
1450 * requires getting a lock on their tables, and the calling user might not
1451 * have privileges for that. We need no lock to examine a table's ACLs,
1452 * so the current feature doesn't have a problem of that sort.
1453 */
1456 else
1457 {
1460 else
1462 }
1465 }
1467 /*
1468 * selectDumpableNamespace: policy-setting subroutine
1469 * Mark a namespace as to be dumped or not
1470 */
1471 static void
1473 {
1474 /*
1475 * If specific tables are being dumped, do not dump any complete
1476 * namespaces. If specific namespaces are being dumped, dump just those
1477 * namespaces. Otherwise, dump all non-system namespaces.
1478 */
1488 {
1489 /*
1490 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
1491 * they are interesting (and not the original ACLs which were set at
1492 * initdb time, see pg_init_privs).
1493 */
1495 }
1498 {
1499 /* Other system schemas don't get dumped */
1501 }
1503 {
1504 /*
1505 * The public schema is a strange beast that sits in a sort of
1506 * no-mans-land between being a system object and a user object. We
1507 * don't want to dump creation or comment commands for it, because
1508 * that complicates matters for non-superuser use of pg_dump. But we
1509 * should dump any ACL changes that have occurred for it, and of
1510 * course we should dump contained objects.
1511 */
1514 }
1515 else
1518 /*
1519 * In any case, a namespace can be excluded by an exclusion switch
1520 */
1526 /*
1527 * If the schema belongs to an extension, allow extension membership to
1528 * override the dump decision for the schema itself. However, this does
1529 * not change dump_contains, so this won't change what we do with objects
1530 * within the schema. (If they belong to the extension, they'll get
1531 * suppressed by it, otherwise not.)
1532 */
1534 }
1536 /*
1537 * selectDumpableTable: policy-setting subroutine
1538 * Mark a table as to be dumped or not
1539 */
1540 static void
1542 {
1546 /*
1547 * If specific tables are being dumped, dump just those tables; else, dump
1548 * according to the parent namespace's dump flag.
1549 */
1554 else
1557 /*
1558 * In any case, a table can be excluded by an exclusion switch
1559 */
1564 }
1566 /*
1567 * selectDumpableType: policy-setting subroutine
1568 * Mark a type as to be dumped or not
1569 *
1570 * If it's a table's rowtype or an autogenerated array type, we also apply a
1571 * special type code to facilitate sorting into the desired order. (We don't
1572 * want to consider those to be ordinary types because that would bring tables
1573 * up into the datatype part of the dump order.) We still set the object's
1574 * dump flag; that's not going to cause the dummy type to be dumped, but we
1575 * need it so that casts involving such types will be dumped correctly -- see
1576 * dumpCast. This means the flag should be set the same as for the underlying
1577 * object (the table or base type).
1578 */
1579 static void
1581 {
1582 /* skip complex types, except for standalone composite types */
1585 {
1591 else
1594 }
1596 /* skip auto-generated array types */
1598 {
1601 /*
1602 * Fall through to set the dump flag; we assume that the subsequent
1603 * rules will do the same thing as they would for the array's base
1604 * type. (We cannot reliably look up the base type here, since
1605 * getTypes may not have processed it yet.)
1606 */
1607 }
1612 /* Dump based on if the contents of the namespace are being dumped */
1614 }
1616 /*
1617 * selectDumpableDefaultACL: policy-setting subroutine
1618 * Mark a default ACL as to be dumped or not
1619 *
1620 * For per-schema default ACLs, dump if the schema is to be dumped.
1621 * Otherwise dump if we are dumping "everything". Note that dataOnly
1622 * and aclsSkip are checked separately.
1623 */
1624 static void
1626 {
1627 /* Default ACLs can't be extension members */
1630 /* default ACLs are considered part of the namespace */
1632 else
1635 }
1637 /*
1638 * selectDumpableCast: policy-setting subroutine
1639 * Mark a cast as to be dumped or not
1640 *
1641 * Casts do not belong to any particular namespace (since they haven't got
1642 * names), nor do they have identifiable owners. To distinguish user-defined
1643 * casts from built-in ones, we must resort to checking whether the cast's
1644 * OID is in the range reserved for initdb.
1645 */
1646 static void
1648 {
1652 /*
1653 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
1654 * support ACLs currently.
1655 */
1658 else
1661 }
1663 /*
1664 * selectDumpableProcLang: policy-setting subroutine
1665 * Mark a procedural language as to be dumped or not
1666 *
1667 * Procedural languages do not belong to any particular namespace. To
1668 * identify built-in languages, we must resort to checking whether the
1669 * language's OID is in the range reserved for initdb.
1670 */
1671 static void
1673 {
1677 /*
1678 * Only include procedural languages when we are dumping everything.
1679 *
1680 * For from-initdb procedural languages, only include ACLs, as we do for
1681 * the pg_catalog namespace. We need this because procedural languages do
1682 * not live in any namespace.
1683 */
1686 else
1687 {
1691 else
1693 }
1694 }
1696 /*
1697 * selectDumpableAccessMethod: policy-setting subroutine
1698 * Mark an access method as to be dumped or not
1699 *
1700 * Access methods do not belong to any particular namespace. To identify
1701 * built-in access methods, we must resort to checking whether the
1702 * method's OID is in the range reserved for initdb.
1703 */
1704 static void
1706 {
1710 /*
1711 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
1712 * they do not support ACLs currently.
1713 */
1716 else
1719 }
1721 /*
1722 * selectDumpableExtension: policy-setting subroutine
1723 * Mark an extension as to be dumped or not
1724 *
1725 * Built-in extensions should be skipped except for checking ACLs, since we
1726 * assume those will already be installed in the target database. We identify
1727 * such extensions by their having OIDs in the range reserved for initdb.
1728 * We dump all user-added extensions by default, or none of them if
1729 * include_everything is false (i.e., a --schema or --table switch was given).
1730 */
1731 static void
1733 {
1734 /*
1735 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
1736 * change permissions on their member objects, if they wish to, and have
1737 * those changes preserved.
1738 */
1741 else
1744 DUMP_COMPONENT_NONE;
1745 }
1747 /*
1748 * selectDumpablePublicationTable: policy-setting subroutine
1749 * Mark a publication table as to be dumped or not
1750 *
1751 * Publication tables have schemas, but those are ignored in decision making,
1752 * because publications are only dumped when we are dumping everything.
1753 */
1754 static void
1756 {
1762 }
1764 /*
1765 * selectDumpableStatisticsObject: policy-setting subroutine
1766 * Mark an extended statistics object as to be dumped or not
1767 *
1768 * We dump an extended statistics object if the schema it's in and the table
1769 * it's for are being dumped. (This'll need more thought if statistics
1770 * objects ever support cross-table stats.)
1771 */
1772 static void
1774 {
1782 }
1784 /*
1785 * selectDumpableObject: policy-setting subroutine
1786 * Mark a generic dumpable object as to be dumped or not
1787 *
1788 * Use this only for object types without a special-case routine above.
1789 */
1790 static void
1792 {
1796 /*
1797 * Default policy is to dump if parent namespace is dumpable, or for
1798 * non-namespace-associated items, dump if we're dumping "everything".
1799 */
1802 else
1805 }
1807 /*
1808 * Dump a table's contents for loading using the COPY command
1809 * - this routine is called by the Archiver when it wants the table
1810 * to be dumped.
1811 */
1813 static int
1815 {
1821 /*
1822 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
1823 * which uses it already.
1824 */
1835 /*
1836 * Specify the column list explicitly so that we have no possibility of
1837 * retrieving data in the wrong column order. (The default column
1838 * ordering of COPY will not be what we want in certain corner cases
1839 * involving ADD COLUMN and inheritance.)
1840 */
1844 {
1845 /* Note: this syntax is only supported in 8.2 and up */
1847 /* klugery to get rid of parens in column list */
1849 {
1852 }
1853 else
1858 }
1859 else
1860 {
1863 column_list);
1864 }
1870 {
1877 {
1880 }
1882 /* ----------
1883 * THROTTLE:
1884 *
1885 * There was considerable discussion in late July, 2000 regarding
1886 * slowing down pg_dump when backing up large tables. Users with both
1887 * slow & fast (multi-processor) machines experienced performance
1888 * degradation when doing a backup.
1889 *
1890 * Initial attempts based on sleeping for a number of ms for each ms
1891 * of work were deemed too complex, then a simple 'sleep in each loop'
1892 * implementation was suggested. The latter failed because the loop
1893 * was too tight. Finally, the following was implemented:
1894 *
1895 * If throttle is non-zero, then
1896 * See how long since the last sleep.
1897 * Work out how long to sleep (based on ratio).
1898 * If sleep is more than 100ms, then
1899 * sleep
1900 * reset timer
1901 * EndIf
1902 * EndIf
1903 *
1904 * where the throttle value was the number of ms to sleep per ms of
1905 * work. The calculation was done in each loop.
1906 *
1907 * Most of the hard work is done in the backend, and this solution
1908 * still did not work particularly well: on slow machines, the ratio
1909 * was 50:1, and on medium paced machines, 1:1, and on fast
1910 * multi-processor machines, it had little or no effect, for reasons
1911 * that were unclear.
1912 *
1913 * Further discussion ensued, and the proposal was dropped.
1914 *
1915 * For those people who want this feature, it can be implemented using
1916 * gettimeofday in each loop, calculating the time since last sleep,
1917 * multiplying that by the sleep ratio, then if the result is more
1918 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
1919 * function to sleep for a subsecond period ie.
1920 *
1921 * select(0, NULL, NULL, NULL, &tvi);
1922 *
1923 * This will return after the interval specified in the structure tvi.
1924 * Finally, call gettimeofday again to save the 'last sleep time'.
1925 * ----------
1926 */
1927 }
1931 {
1932 /* copy data transfer failed */
1933 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
1937 }
1939 /* Check command status and return to normal libpq state */
1942 {
1947 }
1950 /* Do this to ensure we've pumped libpq back to idle state */
1953 classname);
1957 }
1959 /*
1960 * Dump table data using INSERT commands.
1961 *
1962 * Caution: when we restore from an archive file direct to database, the
1963 * INSERT commands emitted by this function have to be parsed by
1964 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
1965 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
1966 */
1967 static int
1969 {
1978 i;
1982 /*
1983 * If we're going to emit INSERTs with column names, the most efficient
1984 * way to deal with generated columns is to exclude them entirely. For
1985 * INSERTs without column names, we have to emit DEFAULT rather than the
1986 * actual column value --- but we can save a few cycles by fetching nulls
1987 * rather than the uninteresting-to-us value.
1988 */
1993 {
2002 else
2005 nfields++;
2006 }
2007 /* Servers before 9.4 will complain about zero-column SELECT */
2018 {
2020 PGRES_TUPLES_OK);
2022 /* cross-check field count, allowing for dummy NULL if any */
2028 /*
2029 * First time through, we build as much of the INSERT statement as
2030 * possible in "insertStmt", which we can then just print for each
2031 * statement. If the table happens to have zero dumpable columns then
2032 * this will be a complete statement, otherwise it will end in
2033 * "VALUES" and be ready to have the row's column values printed.
2034 */
2036 {
2041 /*
2042 * When load-via-partition-root is set or forced, get the root
2043 * table name for the partition table, so that we can reload data
2044 * through the root table.
2045 */
2050 else
2056 /* corner case for zero-column table */
2058 {
2060 }
2061 else
2062 {
2063 /* append the list of column names if required */
2065 {
2068 {
2073 }
2075 }
2081 }
2082 }
2085 {
2086 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2090 /*
2091 * If it is zero-column table then we've already written the
2092 * complete statement, which will mean we've disobeyed
2093 * --rows-per-insert when it's set greater than 1. We do support
2094 * a way to make this multi-row with: SELECT UNION ALL SELECT
2095 * UNION ALL ... but that's non-standard so we should avoid it
2096 * given that using INSERTs is mostly only ever needed for
2097 * cross-database exports.
2098 */
2102 /* Emit a row heading */
2107 else
2111 {
2115 {
2118 }
2120 {
2123 }
2125 /* XXX This code is partially duplicated in ruleutils.c */
2127 {
2135 {
2136 /*
2137 * These types are printed without quotes unless
2138 * they contain values that aren't accepted by the
2139 * scanner unquoted (e.g., 'NaN'). Note that
2140 * strtod() and friends might accept NaN, so we
2141 * can't use that to test.
2142 *
2143 * In reality we only need to defend against
2144 * infinity and NaN, so we need not get too crazy
2145 * about pattern matching here.
2146 */
2151 else
2153 }
2165 else
2170 /* All other types are printed as string literals. */
2174 fout);
2177 }
2178 }
2180 /* Terminate the row ... */
2183 /* ... and the statement, if the target no. of rows is reached */
2185 {
2188 else
2190 /* Reset the row counter */
2192 }
2193 }
2196 {
2199 }
2201 }
2203 /* Terminate any statements that didn't make the row count. */
2205 {
2208 else
2210 }
2222 }
2224 /*
2225 * getRootTableInfo:
2226 * get the root TableInfo for the given partition table.
2227 */
2230 {
2238 {
2241 }
2244 }
2246 /*
2247 * forcePartitionRootLoad
2248 * Check if we must force load_via_partition_root for this partition.
2249 *
2250 * This is required if any level of ancestral partitioned table has an
2251 * unsafe partitioning scheme.
2252 */
2253 static bool
2255 {
2265 {
2270 }
2273 }
2275 /*
2276 * dumpTableData -
2277 * dump the contents of a single table
2278 *
2279 * Actually, this just makes an ArchiveEntry for the table contents.
2280 */
2281 static void
2283 {
2288 DataDumperPtr dumpFn;
2293 /* We had better have loaded per-column details about this table */
2296 /*
2297 * When load-via-partition-root is set or forced, get the root table name
2298 * for the partition table, so that we can reload data through the root
2299 * table. Then construct a comment to be inserted into the TOC entry's
2300 * defn field, so that such cases can be identified reliably.
2301 */
2305 {
2311 copyFrom);
2313 }
2314 else
2318 {
2319 /* Dump/restore using COPY */
2321 /* must use 2 steps here 'cause fmtId is nonreentrant */
2323 copyFrom);
2327 }
2328 else
2329 {
2330 /* Restore using INSERT */
2333 }
2335 /*
2336 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2337 * dependency on its table as "special" and pass it to ArchiveEntry now.
2338 * See comments for BuildArchiveDependencies.
2339 */
2341 {
2357 /*
2358 * Set the TocEntry's dataLength in case we are doing a parallel dump
2359 * and want to order dump jobs by table size. We choose to measure
2360 * dataLength in table pages during dump, so no scaling is needed.
2361 * However, relpages is declared as "integer" in pg_class, and hence
2362 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2363 * Cast so that we get the right interpretation of table sizes
2364 * exceeding INT_MAX pages.
2365 */
2367 }
2371 }
2373 /*
2374 * refreshMatViewData -
2375 * load or refresh the contents of a single materialized view
2376 *
2377 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2378 * statement.
2379 */
2380 static void
2382 {
2384 PQExpBuffer q;
2386 /* If the materialized view is not flagged as populated, skip this. */
2409 }
2411 /*
2412 * getTableData -
2413 * set up dumpable objects representing the contents of tables
2414 */
2415 static void
2417 {
2421 {
2425 }
2426 }
2428 /*
2429 * Make a dumpable object for the data of this specific table
2430 *
2431 * Note: we make a TableDataInfo if and only if we are going to dump the
2432 * table data; the "dump" flag in such objects isn't used.
2433 */
2434 static void
2436 {
2439 /*
2440 * Nothing to do if we already decided to dump the table. This will
2441 * happen for "config" tables.
2442 */
2446 /* Skip VIEWs (no data to dump) */
2449 /* Skip FOREIGN TABLEs (no data to dump) */
2452 /* Skip partitioned tables (data in partitions) */
2456 /* Don't dump data in unlogged tables, if so requested */
2461 /* Check that the data is not explicitly excluded */
2466 /* OK, let's dump it */
2473 else
2476 /*
2477 * Note: use tableoid 0 so that this object won't be mistaken for
2478 * something that pg_depend entries apply to.
2479 */
2491 /* Make sure that we'll collect per-column info for this table. */
2493 }
2495 /*
2496 * The refresh for a materialized view must be dependent on the refresh for
2497 * any materialized view that this one is dependent on.
2498 *
2499 * This must be called after all the objects are created, but before they are
2500 * sorted.
2501 */
2502 static void
2504 {
2505 PQExpBuffer query;
2508 i;
2510 i_objid,
2511 i_refobjid;
2513 /* No Mat Views before 9.3. */
2520 "( "
2521 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
2522 "FROM pg_depend d1 "
2523 "JOIN pg_class c1 ON c1.oid = d1.objid "
2525 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
2526 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
2527 "AND d2.objid = r1.oid "
2528 "AND d2.refobjid <> d1.objid "
2529 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
2532 "WHERE d1.classid = 'pg_class'::regclass "
2533 "UNION "
2534 "SELECT w.objid, d3.refobjid, c3.relkind "
2535 "FROM w "
2536 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
2537 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
2538 "AND d3.objid = r3.oid "
2539 "AND d3.refobjid <> w.refobjid "
2540 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
2543 ") "
2544 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
2545 "FROM w "
2557 {
2558 CatalogId objId;
2559 CatalogId refobjId;
2598 }
2603 }
2605 /*
2606 * getTableDataFKConstraints -
2607 * add dump-order dependencies reflecting foreign key constraints
2608 *
2609 * This code is executed only in a data-only dump --- in schema+data dumps
2610 * we handle foreign key issues by not creating the FK constraints until
2611 * after the data is loaded. In a data-only dump, however, we want to
2612 * order the table data objects in such a way that a table's referenced
2613 * tables are restored first. (In the presence of circular references or
2614 * self-references this may be impossible; we'll detect and complain about
2615 * that during the dependency sorting step.)
2616 */
2617 static void
2619 {
2624 /* Search through all the dumpable objects for FK constraints */
2627 {
2629 {
2633 /* Not interesting unless both tables are to be dumped */
2642 /*
2643 * Okay, make referencing table's TABLE_DATA object depend on the
2644 * referenced table's TABLE_DATA object.
2645 */
2648 }
2649 }
2651 }
2654 /*
2655 * guessConstraintInheritance:
2656 * In pre-8.4 databases, we can't tell for certain which constraints
2657 * are inherited. We assume a CHECK constraint is inherited if its name
2658 * matches the name of any constraint in the parent. Originally this code
2659 * tried to compare the expression texts, but that can fail for various
2660 * reasons --- for example, if the parent and child tables are in different
2661 * schemas, reverse-listing of function calls may produce different text
2662 * (schema-qualified or not) depending on search path.
2663 *
2664 * In 8.4 and up we can rely on the conislocal field to decide which
2665 * constraints must be dumped; much safer.
2666 *
2667 * This function assumes all conislocal flags were initialized to true.
2668 * It clears the flag on anything that seems to be inherited.
2669 */
2670 static void
2672 {
2674 j,
2675 k;
2678 {
2684 /* Sequences and views never have parents */
2689 /* Don't bother computing anything for non-target tables, either */
2699 /* scan for inherited CHECK constraints */
2701 {
2707 {
2712 {
2716 {
2719 }
2720 }
2723 }
2724 }
2725 }
2726 }
2729 /*
2730 * dumpDatabase:
2731 * dump the database definition
2732 */
2733 static void
2735 {
2744 i_oid,
2745 i_datname,
2746 i_dba,
2747 i_encoding,
2748 i_collate,
2749 i_ctype,
2750 i_frozenxid,
2751 i_minmxid,
2752 i_datacl,
2753 i_rdatacl,
2754 i_datistemplate,
2755 i_datconnlimit,
2756 i_tablespace;
2757 CatalogId dbCatId;
2758 DumpId dbDumpId;
2769 uint32 frozenxid,
2770 minmxid;
2775 /*
2776 * Fetch the database-level properties for this database.
2777 *
2778 * The order in which privileges are in the ACL string (the order they
2779 * have been GRANT'd in, which the backend maintains) must be preserved to
2780 * ensure that GRANTs WITH GRANT OPTION and subsequent GRANTs based on
2781 * those are dumped in the correct order. Note that initial privileges
2782 * (pg_init_privs) are not supported on databases, so this logic cannot
2783 * make use of buildACLQueries().
2784 */
2786 {
2788 "(%s datdba) AS dba, "
2789 "pg_encoding_to_char(encoding) AS encoding, "
2790 "datcollate, datctype, datfrozenxid, datminmxid, "
2791 "(SELECT array_agg(acl ORDER BY row_n) FROM "
2792 " (SELECT acl, row_n FROM "
2793 " unnest(coalesce(datacl,acldefault('d',datdba))) "
2794 " WITH ORDINALITY AS perm(acl,row_n) "
2795 " WHERE NOT EXISTS ( "
2796 " SELECT 1 "
2797 " FROM unnest(acldefault('d',datdba)) "
2798 " AS init(init_acl) "
2799 " WHERE acl = init_acl)) AS datacls) "
2800 " AS datacl, "
2801 "(SELECT array_agg(acl ORDER BY row_n) FROM "
2802 " (SELECT acl, row_n FROM "
2803 " unnest(acldefault('d',datdba)) "
2804 " WITH ORDINALITY AS initp(acl,row_n) "
2805 " WHERE NOT EXISTS ( "
2806 " SELECT 1 "
2807 " FROM unnest(coalesce(datacl,acldefault('d',datdba))) "
2808 " AS permp(orig_acl) "
2809 " WHERE acl = orig_acl)) AS rdatacls) "
2810 " AS rdatacl, "
2811 "datistemplate, datconnlimit, "
2812 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
2813 "shobj_description(oid, 'pg_database') AS description "
2815 "FROM pg_database "
2817 username_subquery);
2818 }
2820 {
2822 "(%s datdba) AS dba, "
2823 "pg_encoding_to_char(encoding) AS encoding, "
2824 "datcollate, datctype, datfrozenxid, datminmxid, "
2825 "datacl, '' as rdatacl, datistemplate, datconnlimit, "
2826 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
2827 "shobj_description(oid, 'pg_database') AS description "
2829 "FROM pg_database "
2831 username_subquery);
2832 }
2834 {
2836 "(%s datdba) AS dba, "
2837 "pg_encoding_to_char(encoding) AS encoding, "
2838 "datcollate, datctype, datfrozenxid, 0 AS datminmxid, "
2839 "datacl, '' as rdatacl, datistemplate, datconnlimit, "
2840 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
2841 "shobj_description(oid, 'pg_database') AS description "
2843 "FROM pg_database "
2845 username_subquery);
2846 }
2848 {
2850 "(%s datdba) AS dba, "
2851 "pg_encoding_to_char(encoding) AS encoding, "
2852 "NULL AS datcollate, NULL AS datctype, datfrozenxid, 0 AS datminmxid, "
2853 "datacl, '' as rdatacl, datistemplate, datconnlimit, "
2854 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
2855 "shobj_description(oid, 'pg_database') AS description "
2857 "FROM pg_database "
2859 username_subquery);
2860 }
2861 else
2862 {
2864 "(%s datdba) AS dba, "
2865 "pg_encoding_to_char(encoding) AS encoding, "
2866 "NULL AS datcollate, NULL AS datctype, datfrozenxid, 0 AS datminmxid, "
2867 "datacl, '' as rdatacl, datistemplate, "
2868 "-1 as datconnlimit, "
2869 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace "
2870 "FROM pg_database "
2872 username_subquery);
2873 }
2909 /*
2910 * Prepare the CREATE DATABASE command. We must specify encoding, locale,
2911 * and tablespace since those can't be altered later. Other DB properties
2912 * are left to the DATABASE PROPERTIES entry, so that they can be applied
2913 * after reconnecting to the target DB.
2914 */
2916 qdatname);
2918 {
2921 }
2923 {
2926 }
2928 {
2931 }
2933 /*
2934 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
2935 * thing; the decision whether to specify a tablespace should be left till
2936 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
2937 * label the DATABASE entry with the tablespace and let the normal
2938 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
2939 * attention to default_tablespace, so that won't work.
2940 */
2948 qdatname);
2962 /* Compute correct tag for archive entry */
2965 /* Dump DB comment if any */
2967 {
2968 /*
2969 * 8.2 and up keep comments on shared objects in a shared table, so we
2970 * cannot use the dumpComment() code used for other database objects.
2971 * Be careful that the ArchiveEntry parameters match that function.
2972 */
2976 {
2979 /*
2980 * Generates warning when loaded into a differently-named
2981 * database.
2982 */
2995 }
2996 }
2997 else
2998 {
3001 }
3003 /* Dump DB security label, if enabled */
3005 {
3007 PQExpBuffer seclabelQry;
3026 }
3028 /*
3029 * Dump ACL if any. Note that we do not support initial privileges
3030 * (pg_init_privs) on databases.
3031 */
3036 /*
3037 * Now construct a DATABASE PROPERTIES archive entry to restore any
3038 * non-default database-level properties. (The reason this must be
3039 * separate is that we cannot put any additional commands into the TOC
3040 * entry that has CREATE DATABASE. pg_restore would execute such a group
3041 * in an implicit transaction block, and the backend won't allow CREATE
3042 * DATABASE in that context.)
3043 */
3052 {
3054 qdatname);
3056 /*
3057 * The backend won't accept DROP DATABASE on a template database. We
3058 * can deal with that by removing the template marking before the DROP
3059 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3060 * since no such command is currently supported, fake it with a direct
3061 * UPDATE on pg_database.
3062 */
3067 }
3069 /* Add database-specific SET options */
3072 /*
3073 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3074 * entry, too, for lack of a better place.
3075 */
3077 {
3085 }
3097 /*
3098 * pg_largeobject comes from the old system intact, so set its
3099 * relfrozenxids and relminmxids.
3100 */
3102 {
3107 i_relminmxid;
3109 /*
3110 * pg_largeobject
3111 */
3116 LargeObjectRelationId);
3117 else
3121 LargeObjectRelationId);
3128 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3134 LargeObjectRelationId);
3145 }
3154 }
3156 /*
3157 * Collect any database-specific or role-and-database-specific SET options
3158 * for this database, and append them to outbuf.
3159 */
3160 static void
3163 {
3169 /*
3170 * First collect database-specific options. Pre-8.4 server versions lack
3171 * unnest(), so we do this the hard way by querying once per subscript.
3172 */
3174 {
3179 else
3180 printfPQExpBuffer(buf, "SELECT datconfig[%d] FROM pg_database WHERE oid = '%u'::oid", count, dboid);
3186 {
3189 outbuf);
3191 count++;
3192 }
3193 else
3194 {
3197 }
3198 }
3200 /* Now look for role-and-database-specific options */
3202 {
3203 /* Here we can assume we have unnest() */
3205 "FROM pg_db_role_setting s, pg_roles r "
3207 dboid);
3212 {
3219 outbuf);
3220 }
3223 }
3226 }
3228 /*
3229 * dumpEncoding: put the correct encoding into the archive
3230 */
3231 static void
3233 {
3250 }
3253 /*
3254 * dumpStdStrings: put the correct escape string behavior into the archive
3255 */
3256 static void
3258 {
3263 stdstrings);
3266 stdstrings);
3275 }
3277 /*
3278 * dumpSearchPath: record the active search_path in the archive
3279 */
3280 static void
3282 {
3290 /*
3291 * We use the result of current_schemas(), not the search_path GUC,
3292 * because that might contain wildcards such as "$user", which won't
3293 * necessarily have the same value during restore. Also, this way avoids
3294 * listing schemas that may appear in search_path but not actually exist,
3295 * which seems like a prudent exclusion.
3296 */
3303 /*
3304 * We use set_config(), not a simple "SET search_path" command, because
3305 * the latter has less-clean behavior if the search path is empty. While
3306 * that's likely to get fixed at some point, it seems like a good idea to
3307 * be as backwards-compatible as possible in what we put into archives.
3308 */
3310 {
3314 }
3328 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3336 }
3339 /*
3340 * getBlobs:
3341 * Collect schema-level data about large objects
3342 */
3343 static void
3345 {
3362 /* Fetch BLOB OIDs, and owner/ACL data if >= 9.0 */
3364 {
3375 "SELECT l.oid, (%s l.lomowner) AS rolname, "
3376 "%s AS lomacl, "
3377 "%s AS rlomacl, "
3378 "%s AS initlomacl, "
3379 "%s AS initrlomacl "
3380 "FROM pg_largeobject_metadata l "
3381 "LEFT JOIN pg_init_privs pip ON "
3382 "(l.oid = pip.objoid "
3383 "AND pip.classoid = 'pg_largeobject'::regclass "
3385 username_subquery,
3395 }
3398 "SELECT oid, (%s lomowner) AS rolname, lomacl, "
3399 "NULL AS rlomacl, NULL AS initlomacl, "
3400 "NULL AS initrlomacl "
3402 username_subquery);
3403 else
3405 "SELECT DISTINCT loid AS oid, "
3406 "NULL::name AS rolname, NULL::oid AS lomacl, "
3407 "NULL::oid AS rlomacl, NULL::oid AS initlomacl, "
3408 "NULL::oid AS initrlomacl "
3422 /*
3423 * Each large object has its own BLOB archive entry.
3424 */
3428 {
3447 /*
3448 * In binary-upgrade mode for blobs, we do *not* dump out the blob
3449 * data, as it will be copied by pg_upgrade, which simply copies the
3450 * pg_largeobject table. We *do* however dump out anything but the
3451 * data, as pg_upgrade copies just pg_largeobject, but not
3452 * pg_largeobject_metadata, after the dump is restored.
3453 */
3456 }
3458 /*
3459 * If we have any large objects, a "BLOBS" archive entry is needed. This
3460 * is just a placeholder for sorting; it carries no data now.
3461 */
3463 {
3469 }
3473 }
3475 /*
3476 * dumpBlob
3477 *
3478 * dump the definition (metadata) of the given large object
3479 */
3480 static void
3482 {
3503 /* Dump comment if any */
3509 /* Dump security label if any */
3515 /* Dump ACL if any */
3524 }
3526 /*
3527 * dumpBlobs:
3528 * dump the data contents of all large objects
3529 */
3530 static int
3532 {
3544 /*
3545 * Currently, we re-fetch all BLOB OIDs using a cursor. Consider scanning
3546 * the already-in-memory dumpable objects instead...
3547 */
3549 blobQry =
3550 "DECLARE bloboid CURSOR FOR "
3552 else
3553 blobQry =
3554 "DECLARE bloboid CURSOR FOR "
3559 /* Command to fetch from cursor */
3562 do
3563 {
3564 /* Do a fetch */
3567 /* Process the tuples, if any */
3570 {
3571 Oid blobOid;
3575 /* Open the BLOB */
3583 /* Now read it in chunks, sending data to archive */
3584 do
3585 {
3597 }
3603 }
3605 /*
3606 * getPolicies
3607 * get information about all RLS policies on dumpable tables.
3608 */
3609 void
3611 {
3612 PQExpBuffer query;
3613 PQExpBuffer tbloids;
3626 j,
3627 ntups;
3629 /* No policies before 9.5 */
3636 /*
3637 * Identify tables of interest, and check which ones have RLS enabled.
3638 */
3641 {
3644 /* Ignore row security on tables not to be dumped */
3648 /* It can't have RLS or policies if it's not a table */
3653 /* Add it to the list of table OIDs to be probed below */
3658 /* Is RLS enabled? (That's separate from whether it has policies) */
3660 {
3661 /*
3662 * We represent RLS being enabled on a table by creating a
3663 * PolicyInfo object with null polname.
3664 *
3665 * Note: use tableoid 0 so that this object won't be mistaken for
3666 * something that pg_depend entries apply to.
3667 */
3682 }
3683 }
3686 /*
3687 * Now, read all RLS policies belonging to the tables of interest, and
3688 * create PolicyInfo objects for them. (Note that we must filter the
3689 * results server-side not locally, because we dare not apply pg_get_expr
3690 * to tables we don't have lock on.)
3691 */
3698 else
3701 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
3702 " 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, "
3703 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
3704 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
3713 {
3727 {
3746 else
3751 else
3756 else
3759 }
3760 }
3766 }
3768 /*
3769 * dumpPolicy
3770 * dump the definition of the given policy
3771 */
3772 static void
3774 {
3777 PQExpBuffer query;
3778 PQExpBuffer delqry;
3779 PQExpBuffer polprefix;
3787 /*
3788 * If polname is NULL, then this record is just indicating that ROW LEVEL
3789 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
3790 * ROW LEVEL SECURITY.
3791 */
3793 {
3799 /*
3800 * We must emit the ROW SECURITY object's dependency on its table
3801 * explicitly, because it will not match anything in pg_depend (unlike
3802 * the case for other PolicyInfo objects).
3803 */
3817 }
3829 else
3830 {
3834 }
3886 }
3888 /*
3889 * getPublications
3890 * get information about publications
3891 */
3892 PublicationInfo *
3894 {
3896 PQExpBuffer query;
3909 ntups;
3912 {
3915 }
3921 /* Get the publications. */
3924 "SELECT p.tableoid, p.oid, p.pubname, "
3925 "(%s p.pubowner) AS rolname, "
3926 "p.puballtables, p.pubinsert, p.pubupdate, p.pubdelete, p.pubtruncate "
3928 username_subquery);
3929 else
3931 "SELECT p.tableoid, p.oid, p.pubname, "
3932 "(%s p.pubowner) AS rolname, "
3933 "p.puballtables, p.pubinsert, p.pubupdate, p.pubdelete, false AS pubtruncate "
3935 username_subquery);
3954 {
3977 /* Decide whether we want to dump it */
3979 }
3986 }
3988 /*
3989 * dumpPublication
3990 * dump the definition of the given publication
3991 */
3992 static void
3994 {
3995 PQExpBuffer delq;
3996 PQExpBuffer query;
4009 qpubname);
4012 qpubname);
4019 {
4022 }
4025 {
4031 }
4034 {
4040 }
4043 {
4049 }
4074 }
4076 /*
4077 * getPublicationTables
4078 * get information about publication membership for dumpable tables.
4079 */
4080 void
4082 {
4083 PQExpBuffer query;
4092 j,
4093 ntups;
4100 /* Collect all publication membership info. */
4102 "SELECT tableoid, oid, prpubid, prrelid "
4113 /* this allocation may be more than we need */
4118 {
4124 /*
4125 * Ignore any entries for which we aren't interested in either the
4126 * publication or the rel.
4127 */
4135 /*
4136 * Ignore publication membership of tables whose definitions are not
4137 * to be dumped.
4138 */
4142 /* OK, make a DumpableObject for this relationship */
4153 /* Decide whether we want to dump it */
4156 j++;
4157 }
4161 }
4163 /*
4164 * dumpPublicationTable
4165 * dump the definition of the given publication table mapping
4166 */
4167 static void
4169 {
4172 PQExpBuffer query;
4187 /*
4188 * There is no point in creating a drop query as the drop is done by table
4189 * drop. (If you think to change this, see also _printTocEntry().)
4190 * Although this object doesn't really have ownership as such, set the
4191 * owner field anyway to ensure that the command is run by the correct
4192 * role at restore time.
4193 */
4204 }
4206 /*
4207 * Is the currently connected user a superuser?
4208 */
4209 static bool
4211 {
4221 }
4223 /*
4224 * getSubscriptions
4225 * get information about subscriptions
4226 */
4227 void
4229 {
4231 PQExpBuffer query;
4243 ntups;
4249 {
4253 "SELECT count(*) FROM pg_subscription "
4254 "WHERE subdbid = (SELECT oid FROM pg_database"
4256 PGRES_TUPLES_OK);
4262 }
4268 /* Get the subscriptions in current database. */
4270 "SELECT s.tableoid, s.oid, s.subname,"
4271 "(%s s.subowner) AS rolname, "
4272 " s.subconninfo, s.subslotname, s.subsynccommit, "
4273 " s.subpublications "
4274 "FROM pg_subscription s "
4275 "WHERE s.subdbid = (SELECT oid FROM pg_database"
4277 username_subquery);
4294 {
4305 else
4316 /* Decide whether we want to dump it */
4318 }
4322 }
4324 /*
4325 * dumpSubscription
4326 * dump the definition of the given subscription
4327 */
4328 static void
4330 {
4331 PQExpBuffer delq;
4332 PQExpBuffer query;
4333 PQExpBuffer publications;
4348 qsubname);
4351 qsubname);
4354 /* Build list of quoted publications and append them to query. */
4356 {
4362 }
4366 {
4371 }
4373 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
4376 else
4409 }
4411 /*
4412 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
4413 * the object needs.
4414 */
4415 static void
4417 PQExpBuffer create,
4422 {
4424 {
4427 PQExpBuffer query;
4432 /* dodge fmtId() non-reentrancy */
4437 "SELECT e.extname "
4438 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
4439 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
4440 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
4442 catalog,
4448 {
4452 }
4457 }
4458 }
4461 static void
4463 PQExpBuffer upgrade_buffer,
4464 Oid pg_type_oid,
4466 {
4469 Oid pg_type_array_oid;
4474 pg_type_oid);
4476 /* we only support old >= 8.3 for binary upgrades */
4478 "SELECT typarray "
4479 "FROM pg_catalog.pg_type "
4481 pg_type_oid);
4490 {
4491 /*
4492 * If the old version didn't assign an array type, but the new version
4493 * does, we must select an unused type OID to assign. This currently
4494 * only happens for domains, when upgrading pre-v11 to v11 and up.
4495 *
4496 * Note: local state here is kind of ugly, but we must have some,
4497 * since we mustn't choose the same unused OID more than once.
4498 */
4502 do
4503 {
4506 "SELECT EXISTS(SELECT 1 "
4507 "FROM pg_catalog.pg_type "
4509 next_possible_free_oid);
4516 }
4519 {
4524 pg_type_array_oid);
4525 }
4528 }
4530 static bool
4532 PQExpBuffer upgrade_buffer,
4533 Oid pg_rel_oid)
4534 {
4537 Oid pg_type_oid;
4540 /*
4541 * We only support old >= 8.3 for binary upgrades.
4542 *
4543 * We purposefully ignore toast OIDs for partitioned tables; the reason is
4544 * that versions 10 and 11 have them, but 12 does not, so emitting them
4545 * causes the upgrade to fail.
4546 */
4548 "SELECT c.reltype AS crel, t.reltype AS trel "
4549 "FROM pg_catalog.pg_class c "
4550 "LEFT JOIN pg_catalog.pg_class t ON "
4551 " (c.reltoastrelid = t.oid AND c.relkind <> '%c') "
4563 {
4564 /* Toast tables do not have pg_type array rows */
4568 appendPQExpBufferStr(upgrade_buffer, "\n-- For binary upgrade, must preserve pg_type toast oid\n");
4571 pg_type_toast_oid);
4574 }
4580 }
4582 static void
4586 {
4589 Oid pg_class_reltoastrelid;
4590 Oid pg_index_indexrelid;
4593 "SELECT c.reltoastrelid, i.indexrelid "
4594 "FROM pg_catalog.pg_class c LEFT JOIN "
4595 "pg_catalog.pg_index i ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
4597 pg_class_oid);
4601 pg_class_reltoastrelid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "reltoastrelid")));
4602 pg_index_indexrelid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "indexrelid")));
4608 {
4611 pg_class_oid);
4612 /* only tables have toast tables, not indexes */
4614 {
4615 /*
4616 * One complexity is that the table definition might not require
4617 * the creation of a TOAST table, and the TOAST table might have
4618 * been created long after table creation, when the table was
4619 * loaded with wide data. By setting the TOAST oid we force
4620 * creation of the TOAST heap and TOAST index by the backend so we
4621 * can cleanly copy the files during binary upgrade.
4622 */
4626 pg_class_reltoastrelid);
4628 /* every toast table has an index */
4631 pg_index_indexrelid);
4632 }
4633 }
4634 else
4637 pg_class_oid);
4643 }
4645 /*
4646 * If the DumpableObject is a member of an extension, add a suitable
4647 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
4648 *
4649 * For somewhat historical reasons, objname should already be quoted,
4650 * but not objnamespace (if any).
4651 */
4652 static void
4658 {
4665 /*
4666 * Find the parent extension. We could avoid this search if we wanted to
4667 * add a link field to DumpableObject, but the space costs of that would
4668 * be considerable. We assume that member objects could only have a
4669 * direct dependency on their own extension, not any others.
4670 */
4672 {
4677 }
4686 objtype);
4690 }
4692 /*
4693 * getNamespaces:
4694 * read all namespaces in the system catalogs and return them in the
4695 * NamespaceInfo* structure
4696 *
4697 * numNamespaces is set to the number of namespaces read in
4698 */
4699 NamespaceInfo *
4701 {
4706 PQExpBuffer query;
4719 /*
4720 * we fetch all namespaces including system ones, so that every object we
4721 * read in can be linked to a containing namespace.
4722 */
4724 {
4735 "(%s nspowner) AS rolname, "
4736 "%s as nspacl, "
4737 "%s as rnspacl, "
4738 "%s as initnspacl, "
4739 "%s as initrnspacl "
4740 "FROM pg_namespace n "
4741 "LEFT JOIN pg_init_privs pip "
4742 "ON (n.oid = pip.objoid "
4743 "AND pip.classoid = 'pg_namespace'::regclass "
4745 username_subquery,
4757 }
4758 else
4760 "(%s nspowner) AS rolname, "
4761 "nspacl, NULL as rnspacl, "
4762 "NULL AS initnspacl, NULL as initrnspacl "
4764 username_subquery);
4782 {
4794 /* Decide whether to dump this namespace */
4797 /*
4798 * Do not try to dump ACL if the ACL is empty or the default.
4799 *
4800 * This is useful because, for some schemas/objects, the only
4801 * component we are going to try and dump is the ACL and if we can
4802 * remove that then 'dump' goes to zero/false and we don't consider
4803 * this object for dumping at all later on.
4804 */
4813 }
4821 }
4823 /*
4824 * findNamespace:
4825 * given a namespace OID, look up the info read by getNamespaces
4826 */
4829 {
4836 }
4838 /*
4839 * getExtensions:
4840 * read all extensions in the system catalogs and return them in the
4841 * ExtensionInfo* structure
4842 *
4843 * numExtensions is set to the number of extensions read in
4844 */
4845 ExtensionInfo *
4847 {
4852 PQExpBuffer query;
4863 /*
4864 * Before 9.1, there are no extensions.
4865 */
4867 {
4870 }
4875 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
4876 "FROM pg_extension x "
4895 {
4907 /* Decide whether we want to dump it */
4909 }
4917 }
4919 /*
4920 * getTypes:
4921 * read all types in the system catalogs and return them in the
4922 * TypeInfo* structure
4923 *
4924 * numTypes is set to the number of types read in
4925 *
4926 * NB: this must run after getFuncs() because we assume we can do
4927 * findFuncByOid().
4928 */
4929 TypeInfo *
4931 {
4955 /*
4956 * we include even the built-in types because those may be used as array
4957 * elements by user-defined types
4958 *
4959 * we filter out the built-in types when we dump out the types
4960 *
4961 * same approach for undefined (shell) types and array types
4962 *
4963 * Note: as of 8.3 we can reliably detect whether a type is an
4964 * auto-generated array type by checking the element type's typarray.
4965 * (Before that the test is capable of generating false positives.) We
4966 * still check for name beginning with '_', though, so as to avoid the
4967 * cost of the subselect probe for all standard types. This would have to
4968 * be revisited if the backend ever allows renaming of array types.
4969 */
4972 {
4983 "t.typnamespace, "
4984 "%s AS typacl, "
4985 "%s AS rtypacl, "
4986 "%s AS inittypacl, "
4987 "%s AS initrtypacl, "
4988 "(%s t.typowner) AS rolname, "
4989 "t.typelem, t.typrelid, "
4991 "ELSE (SELECT relkind FROM pg_class WHERE oid = t.typrelid) END AS typrelkind, "
4992 "t.typtype, t.typisdefined, "
4993 "t.typname[0] = '_' AND t.typelem != 0 AND "
4994 "(SELECT typarray FROM pg_type te WHERE oid = t.typelem) = t.oid AS isarray "
4995 "FROM pg_type t "
4996 "LEFT JOIN pg_init_privs pip ON "
4997 "(t.oid = pip.objoid "
4998 "AND pip.classoid = 'pg_type'::regclass "
5004 username_subquery);
5010 }
5012 {
5014 "typnamespace, typacl, NULL as rtypacl, "
5015 "NULL AS inittypacl, NULL AS initrtypacl, "
5016 "(%s typowner) AS rolname, "
5017 "typelem, typrelid, "
5019 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
5020 "typtype, typisdefined, "
5021 "typname[0] = '_' AND typelem != 0 AND "
5022 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
5024 username_subquery);
5025 }
5027 {
5029 "typnamespace, NULL AS typacl, NULL as rtypacl, "
5030 "NULL AS inittypacl, NULL AS initrtypacl, "
5031 "(%s typowner) AS rolname, "
5032 "typelem, typrelid, "
5034 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
5035 "typtype, typisdefined, "
5036 "typname[0] = '_' AND typelem != 0 AND "
5037 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
5039 username_subquery);
5040 }
5041 else
5042 {
5044 "typnamespace, NULL AS typacl, NULL as rtypacl, "
5045 "NULL AS inittypacl, NULL AS initrtypacl, "
5046 "(%s typowner) AS rolname, "
5047 "typelem, typrelid, "
5049 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
5050 "typtype, typisdefined, "
5051 "typname[0] = '_' AND typelem != 0 AS isarray "
5053 username_subquery);
5054 }
5079 {
5102 else
5107 else
5110 /* Decide whether we want to dump it */
5113 /* Do not try to dump ACL if no ACL exists. */
5119 /*
5120 * If it's a domain, fetch info about its constraints, if any
5121 */
5128 /*
5129 * If it's a base type, make a DumpableObject representing a shell
5130 * definition of the type. We will need to dump that ahead of the I/O
5131 * functions for the type. Similarly, range types need a shell
5132 * definition in case they have a canonicalize function.
5133 *
5134 * Note: the shell type doesn't have a catId. You might think it
5135 * should copy the base type's catId, but then it might capture the
5136 * pg_depend entries for the type, which we don't want.
5137 */
5141 {
5151 /*
5152 * Initially mark the shell type as not to be dumped. We'll only
5153 * dump it if the I/O or canonicalize functions need to be dumped;
5154 * this is taken care of while sorting dependencies.
5155 */
5157 }
5162 }
5171 }
5173 /*
5174 * getOperators:
5175 * read all operators in the system catalogs and return them in the
5176 * OprInfo* structure
5177 *
5178 * numOprs is set to the number of operators read in
5179 */
5180 OprInfo *
5182 {
5196 /*
5197 * find all operators, including builtin operators; we filter out
5198 * system-defined operators at dump-out time.
5199 */
5202 "oprnamespace, "
5203 "(%s oprowner) AS rolname, "
5204 "oprkind, "
5205 "oprcode::oid AS oprcode "
5207 username_subquery);
5225 {
5238 /* Decide whether we want to dump it */
5241 /* Operators do not currently have ACLs. */
5247 }
5254 }
5256 /*
5257 * getCollations:
5258 * read all collations in the system catalogs and return them in the
5259 * CollInfo* structure
5260 *
5261 * numCollations is set to the number of collations read in
5262 */
5263 CollInfo *
5265 {
5269 PQExpBuffer query;
5277 /* Collations didn't exist pre-9.1 */
5279 {
5282 }
5286 /*
5287 * find all collations, including builtin collations; we filter out
5288 * system-defined collations at dump-out time.
5289 */
5292 "collnamespace, "
5293 "(%s collowner) AS rolname "
5295 username_subquery);
5311 {
5322 /* Decide whether we want to dump it */
5325 /* Collations do not currently have ACLs. */
5327 }
5334 }
5336 /*
5337 * getConversions:
5338 * read all conversions in the system catalogs and return them in the
5339 * ConvInfo* structure
5340 *
5341 * numConversions is set to the number of conversions read in
5342 */
5343 ConvInfo *
5345 {
5349 PQExpBuffer query;
5359 /*
5360 * find all conversions, including builtin conversions; we filter out
5361 * system-defined conversions at dump-out time.
5362 */
5365 "connamespace, "
5366 "(%s conowner) AS rolname "
5368 username_subquery);
5384 {
5395 /* Decide whether we want to dump it */
5398 /* Conversions do not currently have ACLs. */
5400 }
5407 }
5409 /*
5410 * getAccessMethods:
5411 * read all user-defined access methods in the system catalogs and return
5412 * them in the AccessMethodInfo* structure
5413 *
5414 * numAccessMethods is set to the number of access methods read in
5415 */
5416 AccessMethodInfo *
5418 {
5422 PQExpBuffer query;
5430 /* Before 9.6, there are no user-defined access methods */
5432 {
5435 }
5439 /* Select all access methods from pg_am table */
5441 "amhandler::pg_catalog.regproc AS amhandler "
5458 {
5468 /* Decide whether we want to dump it */
5471 /* Access methods do not currently have ACLs. */
5473 }
5480 }
5483 /*
5484 * getOpclasses:
5485 * read all opclasses in the system catalogs and return them in the
5486 * OpclassInfo* structure
5487 *
5488 * numOpclasses is set to the number of opclasses read in
5489 */
5490 OpclassInfo *
5492 {
5504 /*
5505 * find all opclasses, including builtin opclasses; we filter out
5506 * system-defined opclasses at dump-out time.
5507 */
5510 "opcnamespace, "
5511 "(%s opcowner) AS rolname "
5513 username_subquery);
5529 {
5540 /* Decide whether we want to dump it */
5543 /* Op Classes do not currently have ACLs. */
5549 }
5556 }
5558 /*
5559 * getOpfamilies:
5560 * read all opfamilies in the system catalogs and return them in the
5561 * OpfamilyInfo* structure
5562 *
5563 * numOpfamilies is set to the number of opfamilies read in
5564 */
5565 OpfamilyInfo *
5567 {
5571 PQExpBuffer query;
5579 /* Before 8.3, there is no separate concept of opfamilies */
5581 {
5584 }
5588 /*
5589 * find all opfamilies, including builtin opfamilies; we filter out
5590 * system-defined opfamilies at dump-out time.
5591 */
5594 "opfnamespace, "
5595 "(%s opfowner) AS rolname "
5597 username_subquery);
5613 {
5624 /* Decide whether we want to dump it */
5627 /* Extensions do not currently have ACLs. */
5633 }
5640 }
5642 /*
5643 * getAggregates:
5644 * read all the user-defined aggregates in the system catalogs and
5645 * return them in the AggInfo* structure
5646 *
5647 * numAggs is set to the number of aggregates read in
5648 */
5649 AggInfo *
5651 {
5670 /*
5671 * Find all interesting aggregates. See comment in getFuncs() for the
5672 * rationale behind the filtering logic.
5673 */
5675 {
5690 "p.proname AS aggname, "
5691 "p.pronamespace AS aggnamespace, "
5692 "p.pronargs, p.proargtypes, "
5693 "(%s p.proowner) AS rolname, "
5694 "%s AS aggacl, "
5695 "%s AS raggacl, "
5696 "%s AS initaggacl, "
5697 "%s AS initraggacl "
5698 "FROM pg_proc p "
5699 "LEFT JOIN pg_init_privs pip ON "
5700 "(p.oid = pip.objoid "
5701 "AND pip.classoid = 'pg_proc'::regclass "
5702 "AND pip.objsubid = 0) "
5703 "WHERE %s AND ("
5704 "p.pronamespace != "
5705 "(SELECT oid FROM pg_namespace "
5706 "WHERE nspname = 'pg_catalog') OR "
5708 username_subquery,
5713 agg_check);
5716 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
5717 "classid = 'pg_proc'::regclass AND "
5718 "objid = p.oid AND "
5719 "refclassid = 'pg_extension'::regclass AND "
5727 }
5729 {
5731 "pronamespace AS aggnamespace, "
5732 "pronargs, proargtypes, "
5733 "(%s proowner) AS rolname, "
5734 "proacl AS aggacl, "
5735 "NULL AS raggacl, "
5736 "NULL AS initaggacl, NULL AS initraggacl "
5737 "FROM pg_proc p "
5738 "WHERE proisagg AND ("
5739 "pronamespace != "
5740 "(SELECT oid FROM pg_namespace "
5742 username_subquery);
5745 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
5746 "classid = 'pg_proc'::regclass AND "
5747 "objid = p.oid AND "
5748 "refclassid = 'pg_extension'::regclass AND "
5751 }
5752 else
5753 {
5755 "pronamespace AS aggnamespace, "
5756 "CASE WHEN proargtypes[0] = 'pg_catalog.\"any\"'::pg_catalog.regtype THEN 0 ELSE 1 END AS pronargs, "
5757 "proargtypes, "
5758 "(%s proowner) AS rolname, "
5759 "proacl AS aggacl, "
5760 "NULL AS raggacl, "
5761 "NULL AS initaggacl, NULL AS initraggacl "
5762 "FROM pg_proc "
5763 "WHERE proisagg "
5764 "AND pronamespace != "
5766 username_subquery);
5767 }
5789 {
5811 else
5812 {
5817 }
5819 /* Decide whether we want to dump it */
5822 /* Do not try to dump ACL if no ACL exists. */
5827 }
5834 }
5836 /*
5837 * getFuncs:
5838 * read all the user-defined functions in the system catalogs and
5839 * return them in the FuncInfo* structure
5840 *
5841 * numFuncs is set to the number of functions read in
5842 */
5843 FuncInfo *
5845 {
5866 /*
5867 * Find all interesting functions. This is a bit complicated:
5868 *
5869 * 1. Always exclude aggregates; those are handled elsewhere.
5870 *
5871 * 2. Always exclude functions that are internally dependent on something
5872 * else, since presumably those will be created as a result of creating
5873 * the something else. This currently acts only to suppress constructor
5874 * functions for range types (so we only need it in 9.2 and up). Note
5875 * this is OK only because the constructors don't have any dependencies
5876 * the range type doesn't have; otherwise we might not get creation
5877 * ordering correct.
5878 *
5879 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
5880 * they're members of extensions and we are in binary-upgrade mode then
5881 * include them, since we want to dump extension members individually in
5882 * that mode. Also, if they are used by casts or transforms then we need
5883 * to gather the information about them, though they won't be dumped if
5884 * they are built-in. Also, in 9.6 and up, include functions in
5885 * pg_catalog if they have an ACL different from what's shown in
5886 * pg_init_privs.
5887 */
5889 {
5904 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
5905 "p.pronargs, p.proargtypes, p.prorettype, "
5906 "%s AS proacl, "
5907 "%s AS rproacl, "
5908 "%s AS initproacl, "
5909 "%s AS initrproacl, "
5910 "p.pronamespace, "
5911 "(%s p.proowner) AS rolname "
5912 "FROM pg_proc p "
5913 "LEFT JOIN pg_init_privs pip ON "
5914 "(p.oid = pip.objoid "
5915 "AND pip.classoid = 'pg_proc'::regclass "
5916 "AND pip.objsubid = 0) "
5917 "WHERE %s"
5919 "WHERE classid = 'pg_proc'::regclass AND "
5920 "objid = p.oid AND deptype = 'i')"
5923 "(SELECT oid FROM pg_namespace "
5924 "WHERE nspname = 'pg_catalog')"
5936 username_subquery,
5937 not_agg_check,
5938 g_last_builtin_oid,
5939 g_last_builtin_oid);
5943 "classid = 'pg_proc'::regclass AND "
5944 "objid = p.oid AND "
5945 "refclassid = 'pg_extension'::regclass AND "
5955 }
5956 else
5957 {
5959 "SELECT tableoid, oid, proname, prolang, "
5960 "pronargs, proargtypes, prorettype, proacl, "
5961 "NULL as rproacl, "
5962 "NULL as initproacl, NULL AS initrproacl, "
5963 "pronamespace, "
5964 "(%s proowner) AS rolname "
5965 "FROM pg_proc p "
5967 username_subquery);
5971 "WHERE classid = 'pg_proc'::regclass AND "
5976 "(SELECT oid FROM pg_namespace "
5977 "WHERE nspname = 'pg_catalog')"
5981 g_last_builtin_oid);
5989 g_last_builtin_oid);
5994 "classid = 'pg_proc'::regclass AND "
5995 "objid = p.oid AND "
5996 "refclassid = 'pg_extension'::regclass AND "
5999 }
6024 {
6043 else
6044 {
6048 }
6050 /* Decide whether we want to dump it */
6053 /* Do not try to dump ACL if no ACL exists. */
6062 }
6069 }
6071 /*
6072 * getTables
6073 * read all the tables (no indexes)
6074 * in the system catalogs return them in the TableInfo* structure
6075 *
6076 * numTables is set to the number of tables read in
6077 */
6078 TableInfo *
6080 {
6125 /*
6126 * Find all the tables and table-like objects.
6127 *
6128 * We must fetch all tables in this phase because otherwise we cannot
6129 * correctly identify inherited columns, owned sequences, etc.
6130 *
6131 * We include system catalogs, so that we can work if a user table is
6132 * defined to inherit from a system catalog (pretty weird, but...)
6133 *
6134 * We ignore relations that are not ordinary tables, sequences, views,
6135 * materialized views, composite types, or foreign tables.
6136 *
6137 * Composite-type table entries won't be dumped as such, but we have to
6138 * make a DumpableObject for them so that we can track dependencies of the
6139 * composite type (pg_depend entries for columns of the composite type
6140 * link to the pg_class entry not the pg_type entry).
6141 *
6142 * Note: in this phase we should collect only a minimal amount of
6143 * information about each table, basically just enough to decide if it is
6144 * interesting. In particular, since we do not yet have lock on any user
6145 * table, we MUST NOT invoke any server-side data collection functions
6146 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
6147 * wrong answers if any concurrent DDL is happening.
6148 *
6149 * We purposefully ignore toast OIDs for partitioned tables; the reason is
6150 * that versions 10 and 11 have them, but 12 does not, so emitting them
6151 * causes the upgrade to fail.
6152 */
6155 {
6169 /*
6170 * Collect the information about any partitioned tables, which were
6171 * added in PG10.
6172 */
6176 /* In PG12 upwards WITH OIDS does not exist anymore. */
6180 /*
6181 * Left join to pick up dependency info linking sequences to their
6182 * owning column, if any (note this dependency is AUTO as of 8.2)
6183 *
6184 * Left join to detect if any privileges are still as-set-at-init, in
6185 * which case we won't dump out ACL commands for those.
6186 */
6199 "SELECT c.tableoid, c.oid, c.relname, "
6200 "%s AS relacl, %s as rrelacl, "
6201 "%s AS initrelacl, %s as initrrelacl, "
6202 "c.relkind, c.relnamespace, "
6203 "(%s c.relowner) AS rolname, "
6204 "c.relchecks, c.relhastriggers, "
6205 "c.relhasindex, c.relhasrules, %s AS relhasoids, "
6206 "c.relrowsecurity, c.relforcerowsecurity, "
6207 "c.relfrozenxid, c.relminmxid, tc.oid AS toid, "
6208 "tc.relfrozenxid AS tfrozenxid, "
6209 "tc.relminmxid AS tminmxid, "
6210 "c.relpersistence, c.relispopulated, "
6211 "c.relreplident, c.relpages, am.amname, "
6212 "c.reloftype, "
6213 "d.refobjid AS owning_tab, "
6214 "d.refobjsubid AS owning_col, "
6215 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6216 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6217 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6218 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, "
6219 "tc.reloptions AS toast_reloptions, "
6220 "c.relkind = '%c' AND EXISTS (SELECT 1 FROM pg_depend WHERE classid = 'pg_class'::regclass AND objid = c.oid AND objsubid = 0 AND refclassid = 'pg_class'::regclass AND deptype = 'i') AS is_identity_sequence, "
6221 "EXISTS (SELECT 1 FROM pg_attribute at LEFT JOIN pg_init_privs pip ON "
6222 "(c.oid = pip.objoid "
6223 "AND pip.classoid = 'pg_class'::regclass "
6224 "AND pip.objsubid = at.attnum)"
6225 "WHERE at.attrelid = c.oid AND ("
6226 "%s IS NOT NULL "
6227 "OR %s IS NOT NULL "
6228 "OR %s IS NOT NULL "
6229 "OR %s IS NOT NULL"
6230 "))"
6231 "AS changed_acl, "
6232 "%s AS ispartition "
6233 "FROM pg_class c "
6234 "LEFT JOIN pg_depend d ON "
6235 "(c.relkind = '%c' AND "
6236 "d.classid = c.tableoid AND d.objid = c.oid AND "
6237 "d.objsubid = 0 AND "
6238 "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
6239 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid AND c.relkind <> '%c') "
6240 "LEFT JOIN pg_am am ON (c.relam = am.oid) "
6241 "LEFT JOIN pg_init_privs pip ON "
6242 "(c.oid = pip.objoid "
6243 "AND pip.classoid = 'pg_class'::regclass "
6244 "AND pip.objsubid = 0) "
6245 "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c', '%c') "
6251 username_subquery,
6252 relhasoids,
6253 RELKIND_SEQUENCE,
6258 ispartition,
6259 RELKIND_SEQUENCE,
6260 RELKIND_PARTITIONED_TABLE,
6264 RELKIND_PARTITIONED_TABLE);
6275 }
6277 {
6278 /*
6279 * Left join to pick up dependency info linking sequences to their
6280 * owning column, if any (note this dependency is AUTO as of 8.2)
6281 */
6283 "SELECT c.tableoid, c.oid, c.relname, "
6284 "c.relacl, NULL as rrelacl, "
6285 "NULL AS initrelacl, NULL AS initrrelacl, "
6286 "c.relkind, "
6287 "c.relnamespace, "
6288 "(%s c.relowner) AS rolname, "
6289 "c.relchecks, c.relhastriggers, "
6290 "c.relhasindex, c.relhasrules, c.relhasoids, "
6291 "c.relrowsecurity, c.relforcerowsecurity, "
6292 "c.relfrozenxid, c.relminmxid, tc.oid AS toid, "
6293 "tc.relfrozenxid AS tfrozenxid, "
6294 "tc.relminmxid AS tminmxid, "
6295 "c.relpersistence, c.relispopulated, "
6296 "c.relreplident, c.relpages, "
6297 "NULL AS amname, "
6298 "c.reloftype, "
6299 "d.refobjid AS owning_tab, "
6300 "d.refobjsubid AS owning_col, "
6301 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6302 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6303 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6304 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, "
6305 "tc.reloptions AS toast_reloptions, "
6306 "NULL AS changed_acl, "
6307 "false AS ispartition "
6308 "FROM pg_class c "
6309 "LEFT JOIN pg_depend d ON "
6310 "(c.relkind = '%c' AND "
6311 "d.classid = c.tableoid AND d.objid = c.oid AND "
6312 "d.objsubid = 0 AND "
6313 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6314 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6315 "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
6317 username_subquery,
6318 RELKIND_SEQUENCE,
6322 }
6324 {
6325 /*
6326 * Left join to pick up dependency info linking sequences to their
6327 * owning column, if any (note this dependency is AUTO as of 8.2)
6328 */
6330 "SELECT c.tableoid, c.oid, c.relname, "
6331 "c.relacl, NULL as rrelacl, "
6332 "NULL AS initrelacl, NULL AS initrrelacl, "
6333 "c.relkind, "
6334 "c.relnamespace, "
6335 "(%s c.relowner) AS rolname, "
6336 "c.relchecks, c.relhastriggers, "
6337 "c.relhasindex, c.relhasrules, c.relhasoids, "
6338 "'f'::bool AS relrowsecurity, "
6339 "'f'::bool AS relforcerowsecurity, "
6340 "c.relfrozenxid, c.relminmxid, tc.oid AS toid, "
6341 "tc.relfrozenxid AS tfrozenxid, "
6342 "tc.relminmxid AS tminmxid, "
6343 "c.relpersistence, c.relispopulated, "
6344 "c.relreplident, c.relpages, "
6345 "NULL AS amname, "
6346 "c.reloftype, "
6347 "d.refobjid AS owning_tab, "
6348 "d.refobjsubid AS owning_col, "
6349 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6350 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6351 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6352 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, "
6353 "tc.reloptions AS toast_reloptions, "
6354 "NULL AS changed_acl, "
6355 "false AS ispartition "
6356 "FROM pg_class c "
6357 "LEFT JOIN pg_depend d ON "
6358 "(c.relkind = '%c' AND "
6359 "d.classid = c.tableoid AND d.objid = c.oid AND "
6360 "d.objsubid = 0 AND "
6361 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6362 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6363 "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
6365 username_subquery,
6366 RELKIND_SEQUENCE,
6370 }
6372 {
6373 /*
6374 * Left join to pick up dependency info linking sequences to their
6375 * owning column, if any (note this dependency is AUTO as of 8.2)
6376 */
6378 "SELECT c.tableoid, c.oid, c.relname, "
6379 "c.relacl, NULL as rrelacl, "
6380 "NULL AS initrelacl, NULL AS initrrelacl, "
6381 "c.relkind, "
6382 "c.relnamespace, "
6383 "(%s c.relowner) AS rolname, "
6384 "c.relchecks, c.relhastriggers, "
6385 "c.relhasindex, c.relhasrules, c.relhasoids, "
6386 "'f'::bool AS relrowsecurity, "
6387 "'f'::bool AS relforcerowsecurity, "
6388 "c.relfrozenxid, c.relminmxid, tc.oid AS toid, "
6389 "tc.relfrozenxid AS tfrozenxid, "
6390 "tc.relminmxid AS tminmxid, "
6391 "c.relpersistence, c.relispopulated, "
6392 "'d' AS relreplident, c.relpages, "
6393 "NULL AS amname, "
6394 "c.reloftype, "
6395 "d.refobjid AS owning_tab, "
6396 "d.refobjsubid AS owning_col, "
6397 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6398 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
6399 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
6400 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, "
6401 "tc.reloptions AS toast_reloptions, "
6402 "NULL AS changed_acl, "
6403 "false AS ispartition "
6404 "FROM pg_class c "
6405 "LEFT JOIN pg_depend d ON "
6406 "(c.relkind = '%c' AND "
6407 "d.classid = c.tableoid AND d.objid = c.oid AND "
6408 "d.objsubid = 0 AND "
6409 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6410 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6411 "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
6413 username_subquery,
6414 RELKIND_SEQUENCE,
6418 }
6420 {
6421 /*
6422 * Left join to pick up dependency info linking sequences to their
6423 * owning column, if any (note this dependency is AUTO as of 8.2)
6424 */
6426 "SELECT c.tableoid, c.oid, c.relname, "
6427 "c.relacl, NULL as rrelacl, "
6428 "NULL AS initrelacl, NULL AS initrrelacl, "
6429 "c.relkind, "
6430 "c.relnamespace, "
6431 "(%s c.relowner) AS rolname, "
6432 "c.relchecks, c.relhastriggers, "
6433 "c.relhasindex, c.relhasrules, c.relhasoids, "
6434 "'f'::bool AS relrowsecurity, "
6435 "'f'::bool AS relforcerowsecurity, "
6436 "c.relfrozenxid, 0 AS relminmxid, tc.oid AS toid, "
6437 "tc.relfrozenxid AS tfrozenxid, "
6438 "0 AS tminmxid, "
6439 "c.relpersistence, 't' as relispopulated, "
6440 "'d' AS relreplident, c.relpages, "
6441 "NULL AS amname, "
6442 "c.reloftype, "
6443 "d.refobjid AS owning_tab, "
6444 "d.refobjsubid AS owning_col, "
6445 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6446 "c.reloptions AS reloptions, "
6447 "tc.reloptions AS toast_reloptions, "
6448 "NULL AS changed_acl, "
6449 "false AS ispartition "
6450 "FROM pg_class c "
6451 "LEFT JOIN pg_depend d ON "
6452 "(c.relkind = '%c' AND "
6453 "d.classid = c.tableoid AND d.objid = c.oid AND "
6454 "d.objsubid = 0 AND "
6455 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6456 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6457 "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
6459 username_subquery,
6460 RELKIND_SEQUENCE,
6464 }
6466 {
6467 /*
6468 * Left join to pick up dependency info linking sequences to their
6469 * owning column, if any (note this dependency is AUTO as of 8.2)
6470 */
6472 "SELECT c.tableoid, c.oid, c.relname, "
6473 "c.relacl, NULL as rrelacl, "
6474 "NULL AS initrelacl, NULL AS initrrelacl, "
6475 "c.relkind, "
6476 "c.relnamespace, "
6477 "(%s c.relowner) AS rolname, "
6478 "c.relchecks, c.relhastriggers, "
6479 "c.relhasindex, c.relhasrules, c.relhasoids, "
6480 "'f'::bool AS relrowsecurity, "
6481 "'f'::bool AS relforcerowsecurity, "
6482 "c.relfrozenxid, 0 AS relminmxid, tc.oid AS toid, "
6483 "tc.relfrozenxid AS tfrozenxid, "
6484 "0 AS tminmxid, "
6485 "'p' AS relpersistence, 't' as relispopulated, "
6486 "'d' AS relreplident, c.relpages, "
6487 "NULL AS amname, "
6488 "c.reloftype, "
6489 "d.refobjid AS owning_tab, "
6490 "d.refobjsubid AS owning_col, "
6491 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6492 "c.reloptions AS reloptions, "
6493 "tc.reloptions AS toast_reloptions, "
6494 "NULL AS changed_acl, "
6495 "false AS ispartition "
6496 "FROM pg_class c "
6497 "LEFT JOIN pg_depend d ON "
6498 "(c.relkind = '%c' AND "
6499 "d.classid = c.tableoid AND d.objid = c.oid AND "
6500 "d.objsubid = 0 AND "
6501 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6502 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6503 "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
6505 username_subquery,
6506 RELKIND_SEQUENCE,
6509 }
6511 {
6512 /*
6513 * Left join to pick up dependency info linking sequences to their
6514 * owning column, if any (note this dependency is AUTO as of 8.2)
6515 */
6517 "SELECT c.tableoid, c.oid, c.relname, "
6518 "c.relacl, NULL as rrelacl, "
6519 "NULL AS initrelacl, NULL AS initrrelacl, "
6520 "c.relkind, "
6521 "c.relnamespace, "
6522 "(%s c.relowner) AS rolname, "
6523 "c.relchecks, c.relhastriggers, "
6524 "c.relhasindex, c.relhasrules, c.relhasoids, "
6525 "'f'::bool AS relrowsecurity, "
6526 "'f'::bool AS relforcerowsecurity, "
6527 "c.relfrozenxid, 0 AS relminmxid, tc.oid AS toid, "
6528 "tc.relfrozenxid AS tfrozenxid, "
6529 "0 AS tminmxid, "
6530 "'p' AS relpersistence, 't' as relispopulated, "
6531 "'d' AS relreplident, c.relpages, "
6532 "NULL AS amname, "
6533 "0 AS reloftype, "
6534 "d.refobjid AS owning_tab, "
6535 "d.refobjsubid AS owning_col, "
6536 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6537 "c.reloptions AS reloptions, "
6538 "tc.reloptions AS toast_reloptions, "
6539 "NULL AS changed_acl, "
6540 "false AS ispartition "
6541 "FROM pg_class c "
6542 "LEFT JOIN pg_depend d ON "
6543 "(c.relkind = '%c' AND "
6544 "d.classid = c.tableoid AND d.objid = c.oid AND "
6545 "d.objsubid = 0 AND "
6546 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6547 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6548 "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
6550 username_subquery,
6551 RELKIND_SEQUENCE,
6554 }
6556 {
6557 /*
6558 * Left join to pick up dependency info linking sequences to their
6559 * owning column, if any (note this dependency is AUTO as of 8.2)
6560 */
6562 "SELECT c.tableoid, c.oid, c.relname, "
6563 "c.relacl, NULL as rrelacl, "
6564 "NULL AS initrelacl, NULL AS initrrelacl, "
6565 "c.relkind, "
6566 "c.relnamespace, "
6567 "(%s c.relowner) AS rolname, "
6568 "c.relchecks, (c.reltriggers <> 0) AS relhastriggers, "
6569 "c.relhasindex, c.relhasrules, c.relhasoids, "
6570 "'f'::bool AS relrowsecurity, "
6571 "'f'::bool AS relforcerowsecurity, "
6572 "c.relfrozenxid, 0 AS relminmxid, tc.oid AS toid, "
6573 "tc.relfrozenxid AS tfrozenxid, "
6574 "0 AS tminmxid, "
6575 "'p' AS relpersistence, 't' as relispopulated, "
6576 "'d' AS relreplident, c.relpages, "
6577 "NULL AS amname, "
6578 "0 AS reloftype, "
6579 "d.refobjid AS owning_tab, "
6580 "d.refobjsubid AS owning_col, "
6581 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6582 "c.reloptions AS reloptions, "
6583 "NULL AS toast_reloptions, "
6584 "NULL AS changed_acl, "
6585 "false AS ispartition "
6586 "FROM pg_class c "
6587 "LEFT JOIN pg_depend d ON "
6588 "(c.relkind = '%c' AND "
6589 "d.classid = c.tableoid AND d.objid = c.oid AND "
6590 "d.objsubid = 0 AND "
6591 "d.refclassid = c.tableoid AND d.deptype = 'a') "
6592 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
6593 "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
6595 username_subquery,
6596 RELKIND_SEQUENCE,
6599 }
6600 else
6601 {
6602 /*
6603 * Left join to pick up dependency info linking sequences to their
6604 * owning column, if any
6605 */
6607 "SELECT c.tableoid, c.oid, relname, "
6608 "relacl, NULL as rrelacl, "
6609 "NULL AS initrelacl, NULL AS initrrelacl, "
6610 "relkind, relnamespace, "
6611 "(%s relowner) AS rolname, "
6612 "relchecks, (reltriggers <> 0) AS relhastriggers, "
6613 "relhasindex, relhasrules, relhasoids, "
6614 "'f'::bool AS relrowsecurity, "
6615 "'f'::bool AS relforcerowsecurity, "
6616 "0 AS relfrozenxid, 0 AS relminmxid,"
6617 "0 AS toid, "
6618 "0 AS tfrozenxid, 0 AS tminmxid,"
6619 "'p' AS relpersistence, 't' as relispopulated, "
6620 "'d' AS relreplident, relpages, "
6621 "NULL AS amname, "
6622 "0 AS reloftype, "
6623 "d.refobjid AS owning_tab, "
6624 "d.refobjsubid AS owning_col, "
6625 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
6626 "NULL AS reloptions, "
6627 "NULL AS toast_reloptions, "
6628 "NULL AS changed_acl, "
6629 "false AS ispartition "
6630 "FROM pg_class c "
6631 "LEFT JOIN pg_depend d ON "
6632 "(c.relkind = '%c' AND "
6633 "d.classid = c.tableoid AND d.objid = c.oid AND "
6634 "d.objsubid = 0 AND "
6635 "d.refclassid = c.tableoid AND d.deptype = 'i') "
6636 "WHERE relkind in ('%c', '%c', '%c', '%c') "
6638 username_subquery,
6639 RELKIND_SEQUENCE,
6642 }
6650 /*
6651 * Extract data from result and lock dumpable tables. We do the locking
6652 * before anything else, to minimize the window wherein a table could
6653 * disappear under us.
6654 *
6655 * Note that we have to save info about all tables here, even when dumping
6656 * only one, because we don't yet know which tables might be inheritance
6657 * ancestors of the target table.
6658 */
6700 {
6701 /*
6702 * Arrange to fail instead of waiting forever for a table lock.
6703 *
6704 * NB: this coding assumes that the only queries issued within the
6705 * following loop are LOCK TABLEs; else the timeout may be undesirably
6706 * applied to other things too.
6707 */
6712 }
6715 {
6748 {
6751 }
6752 else
6753 {
6756 }
6761 else
6766 else
6769 /* other fields were zeroed above */
6771 /*
6772 * Decide whether we want to dump this table.
6773 */
6776 else
6779 /*
6780 * If the table-level and all column-level ACLs for this table are
6781 * unchanged, then we don't need to worry about including the ACLs for
6782 * this table. If any column-level ACLs have been changed, the
6783 * 'changed_acl' column from the query will indicate that.
6784 *
6785 * This can result in a significant performance improvement in cases
6786 * where we are only looking to dump out the ACL (eg: pg_catalog).
6787 */
6801 /* Partition? */
6804 /*
6805 * Read-lock target tables to make sure they aren't DROPPED or altered
6806 * in schema before we get around to dumping them.
6807 *
6808 * Note that we don't explicitly lock parents of the target tables; we
6809 * assume our lock on the child is enough to prevent schema
6810 * alterations to parent tables.
6811 *
6812 * NOTE: it'd be kinda nice to lock other relations too, not only
6813 * plain or partitioned tables, but the backend doesn't presently
6814 * allow that.
6815 *
6816 * We only need to lock the table for certain components; see
6817 * pg_dump.h
6818 */
6823 {
6829 }
6831 /* Emit notice if join for owner failed */
6835 }
6838 {
6840 }
6847 }
6849 /*
6850 * getOwnedSeqs
6851 * identify owned sequences and mark them as dumpable if owning table is
6852 *
6853 * We used to do this in getTables(), but it's better to do it after the
6854 * index used by findTableByOid() has been set up.
6855 */
6856 void
6858 {
6861 /*
6862 * Force sequences that are "owned" by table columns to be dumped whenever
6863 * their owning table is being dumped.
6864 */
6866 {
6878 /*
6879 * Only dump identity sequences if we're going to dump the table that
6880 * it belongs to.
6881 */
6884 {
6887 }
6889 /*
6890 * Otherwise we need to dump the components that are being dumped for
6891 * the table and any components which the sequence is explicitly
6892 * marked with.
6893 *
6894 * We can't simply use the set of components which are being dumped
6895 * for the table as the table might be in an extension (and only the
6896 * non-extension components, eg: ACLs if changed, security labels, and
6897 * policies, are being dumped) while the sequence is not (and
6898 * therefore the definition and other components should also be
6899 * dumped).
6900 *
6901 * If the sequence is part of the extension then it should be properly
6902 * marked by checkExtensionMembership() and this will be a no-op as
6903 * the table will be equivalently marked.
6904 */
6909 }
6910 }
6912 /*
6913 * getInherits
6914 * read all the inheritance information
6915 * from the system catalogs return them in the InhInfo* structure
6916 *
6917 * numInherits is set to the number of pairs read in
6918 */
6919 InhInfo *
6921 {
6931 /*
6932 * Find all the inheritance information, excluding implicit inheritance
6933 * via partitioning. We handle that case using getPartitions(), because
6934 * we want more information about partitions than just the parent-child
6935 * relationship.
6936 */
6951 {
6954 }
6961 }
6963 /*
6964 * getPartitioningInfo
6965 * get information about partitioning
6966 *
6967 * For the most part, we only collect partitioning info about tables we
6968 * intend to dump. However, this function has to consider all partitioned
6969 * tables in the database, because we need to know about parents of partitions
6970 * we are going to dump even if the parents themselves won't be dumped.
6971 *
6972 * Specifically, what we need to know is whether each partitioned table
6973 * has an "unsafe" partitioning scheme that requires us to force
6974 * load-via-partition-root mode for its children. Currently the only case
6975 * for which we force that is hash partitioning on enum columns, since the
6976 * hash codes depend on enum value OIDs which won't be replicated across
6977 * dump-and-reload. There are other cases in which load-via-partition-root
6978 * might be necessary, but we expect users to cope with them.
6979 */
6980 void
6982 {
6983 PQExpBuffer query;
6987 /* hash partitioning didn't exist before v11 */
6990 /* needn't bother if schema-only dump */
6996 /*
6997 * Unsafe partitioning schemes are exactly those for which hash enum_ops
6998 * appears among the partition opclasses. We needn't check partstrat.
6999 *
7000 * Note that this query may well retrieve info about tables we aren't
7001 * going to dump and hence have no lock on. That's okay since we need not
7002 * invoke any unsafe server-side functions.
7003 */
7006 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7008 "WHERE opcname = 'enum_ops' "
7009 "AND opcnamespace = 'pg_catalog'::regnamespace "
7017 {
7024 tabrelid);
7026 }
7031 }
7033 /*
7034 * getIndexes
7035 * get information about every index on a dumpable table
7036 *
7037 * Note: index data is not returned directly to the caller, but it
7038 * does get entered into the DumpableObject tables.
7039 */
7040 void
7042 {
7044 j;
7050 i_oid,
7051 i_indexname,
7052 i_parentidx,
7053 i_indexdef,
7054 i_indnkeyatts,
7055 i_indnatts,
7056 i_indkey,
7057 i_indisclustered,
7058 i_indisreplident,
7059 i_contype,
7060 i_conname,
7061 i_condeferrable,
7062 i_condeferred,
7063 i_contableoid,
7064 i_conoid,
7065 i_condef,
7066 i_tablespace,
7067 i_indreloptions,
7068 i_indstatcols,
7069 i_indstatvals;
7073 {
7079 /*
7080 * Ignore indexes of tables whose definitions are not to be dumped.
7081 *
7082 * We also need indexes on partitioned tables which have partitions to
7083 * be dumped, in order to dump the indexes on the partitions.
7084 */
7093 /*
7094 * The point of the messy-looking outer join is to find a constraint
7095 * that is related by an internal dependency link to the index. If we
7096 * find one, create a CONSTRAINT entry linked to the INDEX entry. We
7097 * assume an index won't have more than one internal dependency.
7098 *
7099 * As of 9.0 we don't need to look at pg_depend but can check for a
7100 * match to pg_constraint.conindid. The check on conrelid is
7101 * redundant but useful because that column is indexed while conindid
7102 * is not.
7103 */
7106 {
7108 "SELECT t.tableoid, t.oid, "
7109 "t.relname AS indexname, "
7110 "inh.inhparent AS parentidx, "
7111 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7112 "i.indnkeyatts AS indnkeyatts, "
7113 "i.indnatts AS indnatts, "
7114 "i.indkey, i.indisclustered, "
7115 "i.indisreplident, "
7116 "c.contype, c.conname, "
7117 "c.condeferrable, c.condeferred, "
7118 "c.tableoid AS contableoid, "
7119 "c.oid AS conoid, "
7120 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7121 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7122 "t.reloptions AS indreloptions, "
7123 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7124 " FROM pg_catalog.pg_attribute "
7125 " WHERE attrelid = i.indexrelid AND "
7126 " attstattarget >= 0) AS indstatcols,"
7127 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7128 " FROM pg_catalog.pg_attribute "
7129 " WHERE attrelid = i.indexrelid AND "
7130 " attstattarget >= 0) AS indstatvals "
7131 "FROM pg_catalog.pg_index i "
7132 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7133 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
7134 "LEFT JOIN pg_catalog.pg_constraint c "
7135 "ON (i.indrelid = c.conrelid AND "
7136 "i.indexrelid = c.conindid AND "
7137 "c.contype IN ('p','u','x')) "
7138 "LEFT JOIN pg_catalog.pg_inherits inh "
7139 "ON (inh.inhrelid = indexrelid) "
7140 "WHERE i.indrelid = '%u'::pg_catalog.oid "
7141 "AND (i.indisvalid OR t2.relkind = 'p') "
7142 "AND i.indisready "
7145 }
7147 {
7148 /*
7149 * the test on indisready is necessary in 9.2, and harmless in
7150 * earlier/later versions
7151 */
7153 "SELECT t.tableoid, t.oid, "
7154 "t.relname AS indexname, "
7155 "0 AS parentidx, "
7156 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7157 "i.indnatts AS indnkeyatts, "
7158 "i.indnatts AS indnatts, "
7159 "i.indkey, i.indisclustered, "
7160 "i.indisreplident, "
7161 "c.contype, c.conname, "
7162 "c.condeferrable, c.condeferred, "
7163 "c.tableoid AS contableoid, "
7164 "c.oid AS conoid, "
7165 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7166 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7167 "t.reloptions AS indreloptions, "
7168 "'' AS indstatcols, "
7169 "'' AS indstatvals "
7170 "FROM pg_catalog.pg_index i "
7171 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7172 "LEFT JOIN pg_catalog.pg_constraint c "
7173 "ON (i.indrelid = c.conrelid AND "
7174 "i.indexrelid = c.conindid AND "
7175 "c.contype IN ('p','u','x')) "
7176 "WHERE i.indrelid = '%u'::pg_catalog.oid "
7177 "AND i.indisvalid AND i.indisready "
7180 }
7182 {
7183 /*
7184 * the test on indisready is necessary in 9.2, and harmless in
7185 * earlier/later versions
7186 */
7188 "SELECT t.tableoid, t.oid, "
7189 "t.relname AS indexname, "
7190 "0 AS parentidx, "
7191 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7192 "i.indnatts AS indnkeyatts, "
7193 "i.indnatts AS indnatts, "
7194 "i.indkey, i.indisclustered, "
7195 "false AS indisreplident, "
7196 "c.contype, c.conname, "
7197 "c.condeferrable, c.condeferred, "
7198 "c.tableoid AS contableoid, "
7199 "c.oid AS conoid, "
7200 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7201 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7202 "t.reloptions AS indreloptions, "
7203 "'' AS indstatcols, "
7204 "'' AS indstatvals "
7205 "FROM pg_catalog.pg_index i "
7206 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7207 "LEFT JOIN pg_catalog.pg_constraint c "
7208 "ON (i.indrelid = c.conrelid AND "
7209 "i.indexrelid = c.conindid AND "
7210 "c.contype IN ('p','u','x')) "
7211 "WHERE i.indrelid = '%u'::pg_catalog.oid "
7212 "AND i.indisvalid AND i.indisready "
7215 }
7217 {
7219 "SELECT t.tableoid, t.oid, "
7220 "t.relname AS indexname, "
7221 "0 AS parentidx, "
7222 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7223 "i.indnatts AS indnkeyatts, "
7224 "i.indnatts AS indnatts, "
7225 "i.indkey, i.indisclustered, "
7226 "false AS indisreplident, "
7227 "c.contype, c.conname, "
7228 "c.condeferrable, c.condeferred, "
7229 "c.tableoid AS contableoid, "
7230 "c.oid AS conoid, "
7231 "null AS condef, "
7232 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7233 "t.reloptions AS indreloptions, "
7234 "'' AS indstatcols, "
7235 "'' AS indstatvals "
7236 "FROM pg_catalog.pg_index i "
7237 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7238 "LEFT JOIN pg_catalog.pg_depend d "
7239 "ON (d.classid = t.tableoid "
7240 "AND d.objid = t.oid "
7241 "AND d.deptype = 'i') "
7242 "LEFT JOIN pg_catalog.pg_constraint c "
7243 "ON (d.refclassid = c.tableoid "
7244 "AND d.refobjid = c.oid) "
7245 "WHERE i.indrelid = '%u'::pg_catalog.oid "
7246 "AND i.indisvalid "
7249 }
7250 else
7251 {
7253 "SELECT t.tableoid, t.oid, "
7254 "t.relname AS indexname, "
7255 "0 AS parentidx, "
7256 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7257 "t.relnatts AS indnkeyatts, "
7258 "t.relnatts AS indnatts, "
7259 "i.indkey, i.indisclustered, "
7260 "false AS indisreplident, "
7261 "c.contype, c.conname, "
7262 "c.condeferrable, c.condeferred, "
7263 "c.tableoid AS contableoid, "
7264 "c.oid AS conoid, "
7265 "null AS condef, "
7266 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7267 "null AS indreloptions, "
7268 "'' AS indstatcols, "
7269 "'' AS indstatvals "
7270 "FROM pg_catalog.pg_index i "
7271 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7272 "LEFT JOIN pg_catalog.pg_depend d "
7273 "ON (d.classid = t.tableoid "
7274 "AND d.objid = t.oid "
7275 "AND d.deptype = 'i') "
7276 "LEFT JOIN pg_catalog.pg_constraint c "
7277 "ON (d.refclassid = c.tableoid "
7278 "AND d.refobjid = c.oid) "
7279 "WHERE i.indrelid = '%u'::pg_catalog.oid "
7282 }
7316 {
7344 {
7345 /*
7346 * If we found a constraint matching the index, create an
7347 * entry for it.
7348 */
7361 else
7371 }
7372 else
7373 {
7374 /* Plain secondary index */
7376 }
7377 }
7380 }
7383 }
7385 /*
7386 * getExtendedStatistics
7387 * get information about extended-statistics objects.
7388 *
7389 * Note: extended statistics data is not returned directly to the caller, but
7390 * it does get entered into the DumpableObject tables.
7391 */
7392 void
7394 {
7395 PQExpBuffer query;
7407 /* Extended statistics were new in v10 */
7414 "stxnamespace, (%s stxowner) AS rolname, stxrelid "
7416 username_subquery);
7432 {
7445 /* Decide whether we want to dump it */
7448 /* Stats objects do not currently have ACLs. */
7450 }
7454 }
7456 /*
7457 * getConstraints
7458 *
7459 * Get info about constraints on dumpable tables.
7460 *
7461 * Currently handles foreign keys only.
7462 * Unique and primary key constraints are handled with indexes,
7463 * while check constraints are processed in getTableAttrs().
7464 */
7465 void
7467 {
7469 j;
7471 PQExpBuffer query;
7474 i_conoid,
7475 i_conname,
7476 i_confrelid,
7477 i_conindid,
7478 i_condef;
7484 {
7487 /*
7488 * For partitioned tables, foreign keys have no triggers so they must
7489 * be included anyway in case some foreign keys are defined.
7490 */
7503 "SELECT tableoid, oid, conname, confrelid, conindid, "
7504 "pg_catalog.pg_get_constraintdef(oid) AS condef "
7505 "FROM pg_catalog.pg_constraint "
7506 "WHERE conrelid = '%u'::pg_catalog.oid "
7507 "AND conparentid = 0 "
7510 else
7512 "SELECT tableoid, oid, conname, confrelid, 0 as conindid, "
7513 "pg_catalog.pg_get_constraintdef(oid) AS condef "
7514 "FROM pg_catalog.pg_constraint "
7515 "WHERE conrelid = '%u'::pg_catalog.oid "
7532 {
7552 /*
7553 * Restoring an FK that points to a partitioned table requires
7554 * that all partition indexes have been attached beforehand.
7555 * Ensure that happens by making the constraint depend on each
7556 * index partition attach object.
7557 */
7560 {
7564 {
7566 {
7569 /* not our index? */
7576 }
7577 }
7578 }
7579 }
7582 }
7585 }
7587 /*
7588 * addConstrChildIdxDeps
7589 *
7590 * Recursive subroutine for getConstraints
7591 *
7592 * Given an object representing a foreign key constraint and an index on the
7593 * partitioned table it references, mark the constraint object as dependent
7594 * on each partition, recursing to children until all leaves are found.
7595 * This ensures that the FK is not restored until the index is fully marked
7596 * valid.
7597 */
7598 static void
7600 {
7606 {
7615 }
7616 }
7618 /*
7619 * getDomainConstraints
7620 *
7621 * Get info about constraints on a domain.
7622 */
7623 static void
7625 {
7628 PQExpBuffer query;
7631 i_oid,
7632 i_conname,
7633 i_consrc;
7640 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
7641 "convalidated "
7642 "FROM pg_catalog.pg_constraint "
7643 "WHERE contypid = '%u'::pg_catalog.oid "
7647 else
7649 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
7650 "true as convalidated "
7651 "FROM pg_catalog.pg_constraint "
7652 "WHERE contypid = '%u'::pg_catalog.oid "
7671 {
7692 /*
7693 * Make the domain depend on the constraint, ensuring it won't be
7694 * output till any constraint dependencies are OK. If the constraint
7695 * has not been validated, it's going to be dumped after the domain
7696 * anyway, so this doesn't matter.
7697 */
7701 }
7706 }
7708 /*
7709 * getRules
7710 * get basic information about every rule in the system
7711 *
7712 * numRules is set to the number of rules read in
7713 */
7714 RuleInfo *
7716 {
7731 {
7733 "tableoid, oid, rulename, "
7734 "ev_class AS ruletable, ev_type, is_instead, "
7735 "ev_enabled "
7736 "FROM pg_rewrite "
7738 }
7739 else
7740 {
7742 "tableoid, oid, rulename, "
7743 "ev_class AS ruletable, ev_type, is_instead, "
7744 "'O'::char AS ev_enabled "
7745 "FROM pg_rewrite "
7747 }
7766 {
7767 Oid ruletableoid;
7777 fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
7785 {
7786 /*
7787 * If the table is a view or materialized view, force its ON
7788 * SELECT rule to be sorted before the view itself --- this
7789 * ensures that any dependencies for the rule affect the table's
7790 * positioning. Other rules are forced to appear after their
7791 * table.
7792 */
7796 {
7799 /* We'll merge the rule into CREATE VIEW, if possible */
7801 }
7802 else
7803 {
7807 }
7808 }
7809 else
7811 }
7818 }
7820 /*
7821 * getTriggers
7822 * get information about every trigger on a dumpable table
7823 *
7824 * Note: trigger data is not returned directly to the caller, but it
7825 * does get entered into the DumpableObject tables.
7826 */
7827 void
7829 {
7831 j;
7836 i_oid,
7837 i_tgname,
7838 i_tgfname,
7839 i_tgtype,
7840 i_tgnargs,
7841 i_tgargs,
7842 i_tgisconstraint,
7843 i_tgconstrname,
7844 i_tgconstrrelid,
7845 i_tgconstrrelname,
7846 i_tgenabled,
7847 i_tgisinternal,
7848 i_tgdeferrable,
7849 i_tginitdeferred,
7850 i_tgdef;
7854 {
7867 {
7868 /*
7869 * NB: think not to use pretty=true in pg_get_triggerdef. It
7870 * could result in non-forward-compatible dumps of WHEN clauses
7871 * due to under-parenthesization.
7872 *
7873 * NB: We need to see tgisinternal triggers in partitions, in case
7874 * the tgenabled flag has been changed from the parent.
7875 */
7877 "SELECT t.tgname, "
7878 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7879 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7880 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal "
7881 "FROM pg_catalog.pg_trigger t "
7882 "LEFT JOIN pg_catalog.pg_trigger u ON u.oid = t.tgparentid "
7883 "WHERE t.tgrelid = '%u'::pg_catalog.oid "
7886 }
7888 {
7889 /*
7890 * NB: We need to see tgisinternal triggers in partitions, in case
7891 * the tgenabled flag has been changed from the parent. No
7892 * tgparentid in version 11-12, so we have to match them via
7893 * pg_depend.
7894 *
7895 * See above about pretty=true in pg_get_triggerdef.
7896 */
7898 "SELECT t.tgname, "
7899 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7900 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7901 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal "
7902 "FROM pg_catalog.pg_trigger t "
7903 "LEFT JOIN pg_catalog.pg_depend AS d ON "
7904 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
7905 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
7906 " d.objid = t.oid "
7907 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
7908 "WHERE t.tgrelid = '%u'::pg_catalog.oid "
7913 }
7915 {
7916 /* See above about pretty=true in pg_get_triggerdef */
7918 "SELECT t.tgname, "
7919 "t.tgfoid::pg_catalog.regproc AS tgfname, "
7920 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
7921 "t.tgenabled, false as tgisinternal, "
7922 "t.tableoid, t.oid "
7923 "FROM pg_catalog.pg_trigger t "
7924 "WHERE tgrelid = '%u'::pg_catalog.oid "
7927 }
7929 {
7930 /*
7931 * We ignore triggers that are tied to a foreign-key constraint
7932 */
7934 "SELECT tgname, "
7935 "tgfoid::pg_catalog.regproc AS tgfname, "
7936 "tgtype, tgnargs, tgargs, tgenabled, "
7937 "false as tgisinternal, "
7938 "tgisconstraint, tgconstrname, tgdeferrable, "
7939 "tgconstrrelid, tginitdeferred, tableoid, oid, "
7940 "tgconstrrelid::pg_catalog.regclass AS tgconstrrelname "
7941 "FROM pg_catalog.pg_trigger t "
7942 "WHERE tgrelid = '%u'::pg_catalog.oid "
7945 }
7946 else
7947 {
7948 /*
7949 * We ignore triggers that are tied to a foreign-key constraint,
7950 * but in these versions we have to grovel through pg_constraint
7951 * to find out
7952 */
7954 "SELECT tgname, "
7955 "tgfoid::pg_catalog.regproc AS tgfname, "
7956 "tgtype, tgnargs, tgargs, tgenabled, "
7957 "false as tgisinternal, "
7958 "tgisconstraint, tgconstrname, tgdeferrable, "
7959 "tgconstrrelid, tginitdeferred, tableoid, oid, "
7960 "tgconstrrelid::pg_catalog.regclass AS tgconstrrelname "
7961 "FROM pg_catalog.pg_trigger t "
7962 "WHERE tgrelid = '%u'::pg_catalog.oid "
7963 "AND (NOT tgisconstraint "
7964 " OR NOT EXISTS"
7965 " (SELECT 1 FROM pg_catalog.pg_depend d "
7966 " JOIN pg_catalog.pg_constraint c ON (d.refclassid = c.tableoid AND d.refobjid = c.oid) "
7969 }
7998 {
8009 {
8012 /* remaining fields are not valid if we have tgdef */
8023 }
8024 else
8025 {
8037 {
8041 {
8043 fatal("query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)",
8048 }
8049 else
8051 }
8052 else
8053 {
8057 }
8058 }
8059 }
8062 }
8065 }
8067 /*
8068 * getEventTriggers
8069 * get information about event triggers
8070 */
8071 EventTriggerInfo *
8073 {
8075 PQExpBuffer query;
8079 i_oid,
8080 i_evtname,
8081 i_evtevent,
8082 i_evtowner,
8083 i_evttags,
8084 i_evtfname,
8085 i_evtenabled;
8088 /* Before 9.3, there are no event triggers */
8090 {
8093 }
8098 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8099 "evtevent, (%s evtowner) AS evtowner, "
8100 "array_to_string(array("
8101 "select quote_literal(x) "
8102 " from unnest(evttags) as t(x)), ', ') as evttags, "
8103 "e.evtfoid::regproc as evtfname "
8104 "FROM pg_event_trigger e "
8106 username_subquery);
8126 {
8139 /* Decide whether we want to dump it */
8142 /* Event Triggers do not currently have ACLs. */
8144 }
8151 }
8153 /*
8154 * getProcLangs
8155 * get basic information about every procedural language in the system
8156 *
8157 * numProcLangs is set to the number of langs read in
8158 *
8159 * NB: this must run after getFuncs() because we assume we can do
8160 * findFuncByOid().
8161 */
8162 ProcLangInfo *
8164 {
8185 {
8195 /* pg_language has a laninline column */
8197 "l.lanname, l.lanpltrusted, l.lanplcallfoid, "
8198 "l.laninline, l.lanvalidator, "
8199 "%s AS lanacl, "
8200 "%s AS rlanacl, "
8201 "%s AS initlanacl, "
8202 "%s AS initrlanacl, "
8203 "(%s l.lanowner) AS lanowner "
8204 "FROM pg_language l "
8205 "LEFT JOIN pg_init_privs pip ON "
8206 "(l.oid = pip.objoid "
8207 "AND pip.classoid = 'pg_language'::regclass "
8208 "AND pip.objsubid = 0) "
8209 "WHERE l.lanispl "
8215 username_subquery);
8221 }
8223 {
8224 /* pg_language has a laninline column */
8226 "lanname, lanpltrusted, lanplcallfoid, "
8227 "laninline, lanvalidator, lanacl, NULL AS rlanacl, "
8228 "NULL AS initlanacl, NULL AS initrlanacl, "
8229 "(%s lanowner) AS lanowner "
8230 "FROM pg_language "
8231 "WHERE lanispl "
8233 username_subquery);
8234 }
8236 {
8237 /* pg_language has a lanowner column */
8239 "lanname, lanpltrusted, lanplcallfoid, "
8240 "0 AS laninline, lanvalidator, lanacl, "
8241 "NULL AS rlanacl, "
8242 "NULL AS initlanacl, NULL AS initrlanacl, "
8243 "(%s lanowner) AS lanowner "
8244 "FROM pg_language "
8245 "WHERE lanispl "
8247 username_subquery);
8248 }
8250 {
8251 /* Languages are owned by the bootstrap superuser, OID 10 */
8253 "lanname, lanpltrusted, lanplcallfoid, "
8254 "0 AS laninline, lanvalidator, lanacl, "
8255 "NULL AS rlanacl, "
8256 "NULL AS initlanacl, NULL AS initrlanacl, "
8257 "(%s '10') AS lanowner "
8258 "FROM pg_language "
8259 "WHERE lanispl "
8261 username_subquery);
8262 }
8263 else
8264 {
8265 /* Languages are owned by the bootstrap superuser, sysid 1 */
8267 "lanname, lanpltrusted, lanplcallfoid, "
8268 "0 AS laninline, lanvalidator, lanacl, "
8269 "NULL AS rlanacl, "
8270 "NULL AS initlanacl, NULL AS initrlanacl, "
8271 "(%s '1') AS lanowner "
8272 "FROM pg_language "
8273 "WHERE lanispl "
8275 username_subquery);
8276 }
8300 {
8317 /* Decide whether we want to dump it */
8320 /* Do not try to dump ACL if no ACL exists. */
8325 }
8332 }
8334 /*
8335 * getCasts
8336 * get basic information about every cast in the system
8337 *
8338 * numCasts is set to the number of casts read in
8339 */
8340 CastInfo *
8342 {
8357 {
8359 "castsource, casttarget, castfunc, castcontext, "
8360 "castmethod "
8362 }
8363 else
8364 {
8366 "castsource, casttarget, castfunc, castcontext, "
8367 "CASE WHEN castfunc = 0 THEN 'b' ELSE 'f' END AS castmethod "
8369 }
8388 {
8389 PQExpBufferData namebuf;
8403 /*
8404 * Try to name cast as concatenation of typnames. This is only used
8405 * for purposes of sorting. If we fail to find either type, the name
8406 * will be an empty string.
8407 */
8416 /* Decide whether we want to dump it */
8419 /* Casts do not currently have ACLs. */
8421 }
8428 }
8432 {
8433 PQExpBuffer query;
8445 }
8447 /*
8448 * getTransforms
8449 * get basic information about every transform in the system
8450 *
8451 * numTransforms is set to the number of transforms read in
8452 */
8453 TransformInfo *
8455 {
8459 PQExpBuffer query;
8468 /* Transforms didn't exist pre-9.5 */
8470 {
8473 }
8478 "trftype, trflang, trffromsql::oid, trftosql::oid "
8479 "FROM pg_transform "
8498 {
8499 PQExpBufferData namebuf;
8512 /*
8513 * Try to name transform as concatenation of type and language name.
8514 * This is only used for purposes of sorting. If we fail to find
8515 * either, the name will be an empty string.
8516 */
8526 /* Decide whether we want to dump it */
8528 }
8535 }
8537 /*
8538 * getTableAttrs -
8539 * for each interesting table, read info about its attributes
8540 * (names, types, default values, CHECK constraints, etc)
8541 *
8542 * This is implemented in a very inefficient way right now, looping
8543 * through the tblinfo and doing a join per table to find the attrs and their
8544 * types. However, because we want type names and so forth to be named
8545 * relative to the schema of each table, we couldn't do it in just one
8546 * query. (Maybe one query per schema?)
8547 *
8548 * modifies tblinfo
8549 */
8550 void
8552 {
8555 j;
8581 {
8584 /* Don't bother to collect info for sequences */
8588 /* Don't bother with uninteresting tables, either */
8592 /* find all the user attributes and their types */
8594 /*
8595 * we must read the attribute names in attribute number order! because
8596 * we will use the attnum to index into the attnames array later.
8597 */
8623 else
8629 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
8631 else
8638 else
8644 "pg_catalog.array_to_string(ARRAY("
8645 "SELECT pg_catalog.quote_ident(option_name) || "
8646 "' ' || pg_catalog.quote_literal(option_value) "
8647 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
8648 "ORDER BY option_name"
8650 else
8655 {
8656 /*
8657 * Since we only want to dump COLLATE clauses for attributes whose
8658 * collation is different from their type's default, we use a CASE
8659 * here to suppress uninteresting attcollations cheaply.
8660 */
8662 "CASE WHEN a.attcollation <> t.typcollation "
8664 }
8665 else
8672 else
8676 /* need left join here to not fail on dropped columns ... */
8678 "FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
8680 "WHERE a.attrelid = '%u'::pg_catalog.oid "
8732 {
8744 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
8757 /* these flags will be set in flagInhAttrs() */
8759 }
8763 /*
8764 * Get info about column defaults
8765 */
8767 {
8776 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc "
8777 "FROM pg_catalog.pg_attrdef "
8787 {
8796 /*
8797 * dropped columns shouldn't have defaults, but just in case,
8798 * ignore 'em
8799 */
8816 /*
8817 * Figure out whether the default/generation expression should
8818 * be dumped as part of the main CREATE TABLE (or similar)
8819 * command or as a separate ALTER TABLE (or similar) command.
8820 * The preference is to put it into the CREATE command, but in
8821 * some cases that's not possible.
8822 */
8824 {
8825 /*
8826 * Column generation expressions cannot be dumped
8827 * separately, because there is no syntax for it. The
8828 * !shouldPrintColumn case below will be tempted to set
8829 * them to separate if they are attached to an inherited
8830 * column without a local definition, but that would be
8831 * wrong and unnecessary, because generation expressions
8832 * are always inherited, so there is no need to set them
8833 * again in child tables, and there is no syntax for it
8834 * either. By setting separate to false here we prevent
8835 * the "default" from being processed as its own dumpable
8836 * object, and flagInhAttrs() will remove it from the
8837 * table when it detects that it belongs to an inherited
8838 * column.
8839 */
8841 }
8843 {
8844 /*
8845 * Defaults on a VIEW must always be dumped as separate
8846 * ALTER TABLE commands.
8847 */
8849 }
8851 {
8852 /* column will be suppressed, print default separately */
8854 }
8855 else
8856 {
8858 }
8861 {
8862 /*
8863 * Mark the default as needing to appear before the table,
8864 * so that any dependencies it has must be emitted before
8865 * the CREATE TABLE. If this is not possible, we'll
8866 * change to "separate" mode while sorting dependencies.
8867 */
8870 }
8873 }
8875 }
8877 /*
8878 * Get info about table CHECK constraints
8879 */
8881 {
8891 {
8892 /*
8893 * convalidated is new in 9.2 (actually, it is there in 9.1,
8894 * but it wasn't ever false for check constraints until 9.2).
8895 */
8897 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8898 "conislocal, convalidated "
8899 "FROM pg_catalog.pg_constraint "
8900 "WHERE conrelid = '%u'::pg_catalog.oid "
8901 " AND contype = 'c' "
8904 }
8906 {
8907 /* conislocal is new in 8.4 */
8909 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8910 "conislocal, true AS convalidated "
8911 "FROM pg_catalog.pg_constraint "
8912 "WHERE conrelid = '%u'::pg_catalog.oid "
8913 " AND contype = 'c' "
8916 }
8917 else
8918 {
8920 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8921 "true AS conislocal, true AS convalidated "
8922 "FROM pg_catalog.pg_constraint "
8923 "WHERE conrelid = '%u'::pg_catalog.oid "
8924 " AND contype = 'c' "
8927 }
8933 {
8940 }
8946 {
8965 /*
8966 * An unvalidated constraint needs to be dumped separately, so
8967 * that potentially-violating existing data is loaded before
8968 * the constraint.
8969 */
8974 /*
8975 * Mark the constraint as needing to appear before the table
8976 * --- this is so that any other dependencies of the
8977 * constraint will be emitted before we try to create the
8978 * table. If the constraint is to be dumped separately, it
8979 * will be dumped after data is loaded anyway, so don't do it.
8980 * (There's an automatic dependency in the opposite direction
8981 * anyway, so don't need to add one manually here.)
8982 */
8987 /*
8988 * If the constraint is inherited, this will be detected later
8989 * (in pre-8.4 databases). We also detect later if the
8990 * constraint must be split out from the table definition.
8991 */
8992 }
8994 }
8995 }
8998 }
9000 /*
9001 * Test whether a column should be printed as part of table's CREATE TABLE.
9002 * Column number is zero-based.
9003 *
9004 * Normally this is always true, but it's false for dropped columns, as well
9005 * as those that were inherited without any local definition. (If we print
9006 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
9007 * For partitions, it's always true, because we want the partitions to be
9008 * created independently and ATTACH PARTITION used afterwards.
9009 *
9010 * In binary_upgrade mode, we must print all columns and fix the attislocal/
9011 * attisdropped state later, so as to keep control of the physical column
9012 * order.
9013 *
9014 * This function exists because there are scattered nonobvious places that
9015 * must be kept in sync with this decision.
9016 */
9017 bool
9019 {
9025 }
9028 /*
9029 * getTSParsers:
9030 * read all text search parsers in the system catalogs and return them
9031 * in the TSParserInfo* structure
9032 *
9033 * numTSParsers is set to the number of parsers read in
9034 */
9035 TSParserInfo *
9037 {
9041 PQExpBuffer query;
9053 /* Before 8.3, there is no built-in text search support */
9055 {
9058 }
9062 /*
9063 * find all text search objects, including builtin ones; we filter out
9064 * system-defined objects at dump-out time.
9065 */
9068 "prsstart::oid, prstoken::oid, "
9069 "prsend::oid, prsheadline::oid, prslextype::oid "
9090 {
9105 /* Decide whether we want to dump it */
9108 /* Text Search Parsers do not currently have ACLs. */
9110 }
9117 }
9119 /*
9120 * getTSDictionaries:
9121 * read all text search dictionaries in the system catalogs and return them
9122 * in the TSDictInfo* structure
9123 *
9124 * numTSDicts is set to the number of dictionaries read in
9125 */
9126 TSDictInfo *
9128 {
9132 PQExpBuffer query;
9142 /* Before 8.3, there is no built-in text search support */
9144 {
9147 }
9152 "dictnamespace, (%s dictowner) AS rolname, "
9153 "dicttemplate, dictinitoption "
9155 username_subquery);
9173 {
9186 else
9189 /* Decide whether we want to dump it */
9192 /* Text Search Dictionaries do not currently have ACLs. */
9194 }
9201 }
9203 /*
9204 * getTSTemplates:
9205 * read all text search templates in the system catalogs and return them
9206 * in the TSTemplateInfo* structure
9207 *
9208 * numTSTemplates is set to the number of templates read in
9209 */
9210 TSTemplateInfo *
9212 {
9216 PQExpBuffer query;
9225 /* Before 8.3, there is no built-in text search support */
9227 {
9230 }
9235 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
9253 {
9265 /* Decide whether we want to dump it */
9268 /* Text Search Templates do not currently have ACLs. */
9270 }
9277 }
9279 /*
9280 * getTSConfigurations:
9281 * read all text search configurations in the system catalogs and return
9282 * them in the TSConfigInfo* structure
9283 *
9284 * numTSConfigs is set to the number of configurations read in
9285 */
9286 TSConfigInfo *
9288 {
9292 PQExpBuffer query;
9301 /* Before 8.3, there is no built-in text search support */
9303 {
9306 }
9311 "cfgnamespace, (%s cfgowner) AS rolname, cfgparser "
9313 username_subquery);
9330 {
9342 /* Decide whether we want to dump it */
9345 /* Text Search Configurations do not currently have ACLs. */
9347 }
9354 }
9356 /*
9357 * getForeignDataWrappers:
9358 * read all foreign-data wrappers in the system catalogs and return
9359 * them in the FdwInfo* structure
9360 *
9361 * numForeignDataWrappers is set to the number of fdws read in
9362 */
9363 FdwInfo *
9365 {
9370 PQExpBuffer query;
9384 /* Before 8.4, there are no foreign-data wrappers */
9386 {
9389 }
9394 {
9405 "(%s f.fdwowner) AS rolname, "
9406 "f.fdwhandler::pg_catalog.regproc, "
9407 "f.fdwvalidator::pg_catalog.regproc, "
9408 "%s AS fdwacl, "
9409 "%s AS rfdwacl, "
9410 "%s AS initfdwacl, "
9411 "%s AS initrfdwacl, "
9412 "array_to_string(ARRAY("
9413 "SELECT quote_ident(option_name) || ' ' || "
9414 "quote_literal(option_value) "
9415 "FROM pg_options_to_table(f.fdwoptions) "
9416 "ORDER BY option_name"
9418 "FROM pg_foreign_data_wrapper f "
9419 "LEFT JOIN pg_init_privs pip ON "
9420 "(f.oid = pip.objoid "
9421 "AND pip.classoid = 'pg_foreign_data_wrapper'::regclass "
9423 username_subquery,
9433 }
9435 {
9437 "(%s fdwowner) AS rolname, "
9438 "fdwhandler::pg_catalog.regproc, "
9439 "fdwvalidator::pg_catalog.regproc, fdwacl, "
9440 "NULL as rfdwacl, "
9441 "NULL as initfdwacl, NULL AS initrfdwacl, "
9442 "array_to_string(ARRAY("
9443 "SELECT quote_ident(option_name) || ' ' || "
9444 "quote_literal(option_value) "
9445 "FROM pg_options_to_table(fdwoptions) "
9446 "ORDER BY option_name"
9449 username_subquery);
9450 }
9451 else
9452 {
9454 "(%s fdwowner) AS rolname, "
9455 "'-' AS fdwhandler, "
9456 "fdwvalidator::pg_catalog.regproc, fdwacl, "
9457 "NULL as rfdwacl, "
9458 "NULL as initfdwacl, NULL AS initrfdwacl, "
9459 "array_to_string(ARRAY("
9460 "SELECT quote_ident(option_name) || ' ' || "
9461 "quote_literal(option_value) "
9462 "FROM pg_options_to_table(fdwoptions) "
9463 "ORDER BY option_name"
9466 username_subquery);
9467 }
9489 {
9505 /* Decide whether we want to dump it */
9508 /* Do not try to dump ACL if no ACL exists. */
9513 }
9520 }
9522 /*
9523 * getForeignServers:
9524 * read all foreign servers in the system catalogs and return
9525 * them in the ForeignServerInfo * structure
9526 *
9527 * numForeignServers is set to the number of servers read in
9528 */
9529 ForeignServerInfo *
9531 {
9536 PQExpBuffer query;
9551 /* Before 8.4, there are no foreign servers */
9553 {
9556 }
9561 {
9572 "(%s f.srvowner) AS rolname, "
9573 "f.srvfdw, f.srvtype, f.srvversion, "
9574 "%s AS srvacl, "
9575 "%s AS rsrvacl, "
9576 "%s AS initsrvacl, "
9577 "%s AS initrsrvacl, "
9578 "array_to_string(ARRAY("
9579 "SELECT quote_ident(option_name) || ' ' || "
9580 "quote_literal(option_value) "
9581 "FROM pg_options_to_table(f.srvoptions) "
9582 "ORDER BY option_name"
9584 "FROM pg_foreign_server f "
9585 "LEFT JOIN pg_init_privs pip "
9586 "ON (f.oid = pip.objoid "
9587 "AND pip.classoid = 'pg_foreign_server'::regclass "
9589 username_subquery,
9599 }
9600 else
9601 {
9603 "(%s srvowner) AS rolname, "
9604 "srvfdw, srvtype, srvversion, srvacl, "
9605 "NULL AS rsrvacl, "
9606 "NULL AS initsrvacl, NULL AS initrsrvacl, "
9607 "array_to_string(ARRAY("
9608 "SELECT quote_ident(option_name) || ' ' || "
9609 "quote_literal(option_value) "
9610 "FROM pg_options_to_table(srvoptions) "
9611 "ORDER BY option_name"
9614 username_subquery);
9615 }
9638 {
9655 /* Decide whether we want to dump it */
9658 /* Do not try to dump ACL if no ACL exists. */
9663 }
9670 }
9672 /*
9673 * getDefaultACLs:
9674 * read all default ACL information in the system catalogs and return
9675 * them in the DefaultACLInfo structure
9676 *
9677 * numDefaultACLs is set to the number of ACLs read in
9678 */
9679 DefaultACLInfo *
9681 {
9684 PQExpBuffer query;
9696 ntups;
9699 {
9702 }
9707 {
9713 /*
9714 * Global entries (with defaclnamespace=0) replace the hard-wired
9715 * default ACL for their object type. We should dump them as deltas
9716 * from the default ACL, since that will be used as a starting point
9717 * for interpreting the ALTER DEFAULT PRIVILEGES commands. On the
9718 * other hand, non-global entries can only add privileges not revoke
9719 * them. We must dump those as-is (i.e., as deltas from an empty
9720 * ACL). We implement that by passing NULL as the object type for
9721 * acldefault(), which works because acldefault() is STRICT.
9722 *
9723 * We can use defaclobjtype as the object type for acldefault(),
9724 * except for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be
9725 * converted to 's'.
9726 */
9729 "CASE WHEN defaclnamespace = 0 THEN"
9731 " ELSE defaclobjtype END "
9736 "(%s d.defaclrole) AS defaclrole, "
9737 "d.defaclnamespace, "
9738 "d.defaclobjtype, "
9739 "%s AS defaclacl, "
9740 "%s AS rdefaclacl, "
9741 "%s AS initdefaclacl, "
9742 "%s AS initrdefaclacl "
9743 "FROM pg_default_acl d "
9744 "LEFT JOIN pg_init_privs pip ON "
9745 "(d.oid = pip.objoid "
9746 "AND pip.classoid = 'pg_default_acl'::regclass "
9748 username_subquery,
9758 }
9759 else
9760 {
9762 "(%s defaclrole) AS defaclrole, "
9763 "defaclnamespace, "
9764 "defaclobjtype, "
9765 "defaclacl, "
9766 "NULL AS rdefaclacl, "
9767 "NULL AS initdefaclacl, "
9768 "NULL AS initrdefaclacl "
9770 username_subquery);
9771 }
9791 {
9798 /* cheesy ... is it worth coming up with a better object name? */
9803 else
9813 /* Decide whether we want to dump it */
9815 }
9822 }
9824 /*
9825 * dumpComment --
9826 *
9827 * This routine is used to dump any comments associated with the
9828 * object handed to this routine. The routine takes the object type
9829 * and object name (ready to print, except for schema decoration), plus
9830 * the namespace and owner of the object (for labeling the ArchiveEntry),
9831 * plus catalog ID and subid which are the lookup key for pg_description,
9832 * plus the dump ID for the object (for setting a dependency).
9833 * If a matching pg_description entry is found, it is dumped.
9834 *
9835 * Note: in some cases, such as comments for triggers and rules, the "type"
9836 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
9837 * but it doesn't seem worth complicating the API for all callers to make
9838 * it cleaner.
9839 *
9840 * Note: although this routine takes a dumpId for dependency purposes,
9841 * that purpose is just to mark the dependency in the emitted dump file
9842 * for possible future use by pg_restore. We do NOT use it for determining
9843 * ordering of the comment in the dump file, because this routine is called
9844 * after dependency sorting occurs. This routine should be called just after
9845 * calling ArchiveEntry() for the specified object.
9846 */
9847 static void
9851 {
9856 /* do nothing, if --no-comments is supplied */
9860 /* Comments are schema not data ... except blob comments are data */
9862 {
9865 }
9866 else
9867 {
9868 /* We do dump blob comments in binary-upgrade mode */
9871 }
9873 /* Search for comments associated with catalogId, using table */
9877 /* Is there one matching the subid? */
9879 {
9882 comments++;
9883 ncomments--;
9884 }
9886 /* If a comment exists, build COMMENT ON statement */
9888 {
9901 /*
9902 * We mark comments as SECTION_NONE because they really belong in the
9903 * same section as their parent, whether that is pre-data or
9904 * post-data.
9905 */
9918 }
9919 }
9921 /*
9922 * dumpTableComment --
9923 *
9924 * As above, but dump comments for both the specified table (or view)
9925 * and its columns.
9926 */
9927 static void
9930 {
9934 PQExpBuffer query;
9935 PQExpBuffer tag;
9937 /* do nothing, if --no-comments is supplied */
9941 /* Comments are SCHEMA not data */
9945 /* Search for comments associated with relation, using table */
9951 /* If comments exist, build COMMENT ON statements */
9959 {
9964 {
9984 }
9986 {
10009 }
10011 comments++;
10012 ncomments--;
10013 }
10017 }
10019 /*
10020 * findComments --
10021 *
10022 * Find the comment(s), if any, associated with the given object. All the
10023 * objsubid values associated with the given classoid/objoid are found with
10024 * one search.
10025 */
10026 static int
10029 {
10030 /* static storage for table of comments */
10039 /* Get comments if we didn't already */
10043 /*
10044 * Do binary search to find some item matching the object.
10045 */
10049 {
10060 else
10062 }
10065 {
10068 }
10070 /*
10071 * Now determine how many items match the object. The search loop
10072 * invariant still holds: only items between low and high inclusive could
10073 * match.
10074 */
10077 {
10081 middle--;
10082 nmatch++;
10083 }
10089 {
10093 middle++;
10094 nmatch++;
10095 }
10098 }
10100 /*
10101 * collectComments --
10102 *
10103 * Construct a table of all comments available for database objects.
10104 * We used to do per-object queries for the comments, but it's much faster
10105 * to pull them all over at once, and on most databases the memory cost
10106 * isn't high.
10107 *
10108 * The table is sorted by classoid/objid/objsubid for speed in lookup.
10109 */
10110 static int
10112 {
10114 PQExpBuffer query;
10126 "FROM pg_catalog.pg_description "
10131 /* Construct lookup table containing OIDs in numeric form */
10143 {
10148 }
10150 /* Do NOT free the PGresult since we are keeping pointers into it */
10155 }
10157 /*
10158 * dumpDumpableObject
10159 *
10160 * This routine and its subsidiaries are responsible for creating
10161 * ArchiveEntries (TOC objects) for each object to be dumped.
10162 */
10163 static void
10165 {
10167 {
10253 /* table rowtypes and array types are never dumped separately */
10281 {
10290 /*
10291 * Set the TocEntry's dataLength in case we are doing a
10292 * parallel dump and want to order dump jobs by table size.
10293 * (We need some size estimate for every TocEntry with a
10294 * DataDumper function.) We don't currently have any cheap
10295 * way to estimate the size of blobs, but it doesn't matter;
10296 * let's just set the size to a large value so parallel dumps
10297 * will launch this job first. If there's lots of blobs, we
10298 * win, and if there aren't, we don't lose much. (If you want
10299 * to improve on this, really what you should be thinking
10300 * about is allowing blob dumping to be parallelized, not just
10301 * getting a smarter estimate for the single TOC entry.)
10302 */
10304 }
10320 /* never dumped, nothing to do */
10322 }
10323 }
10325 /*
10326 * dumpNamespace
10327 * writes out to fout the queries to recreate a user-defined namespace
10328 */
10329 static void
10331 {
10333 PQExpBuffer q;
10334 PQExpBuffer delq;
10337 /* Skip if not to be dumped */
10363 /* Dump Schema Comments and Security Labels */
10384 }
10386 /*
10387 * dumpExtension
10388 * writes out to fout the queries to recreate an extension
10389 */
10390 static void
10392 {
10394 PQExpBuffer q;
10395 PQExpBuffer delq;
10398 /* Skip if not to be dumped */
10410 {
10411 /*
10412 * In a regular dump, we simply create the extension, intentionally
10413 * not specifying a version, so that the destination installation's
10414 * default version is used.
10415 *
10416 * Use of IF NOT EXISTS here is unlike our behavior for other object
10417 * types; but there are various scenarios in which it's convenient to
10418 * manually create the desired extension before restoring, so we
10419 * prefer to allow it to exist already.
10420 */
10423 }
10424 else
10425 {
10426 /*
10427 * In binary-upgrade mode, it's critical to reproduce the state of the
10428 * database exactly, so our procedure is to create an empty extension,
10429 * restore all the contained objects normally, and add them to the
10430 * extension one by one. This function performs just the first of
10431 * those steps. binary_upgrade_extension_member() takes care of
10432 * adding member objects as they're created.
10433 */
10437 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
10439 /*
10440 * We unconditionally create the extension, so we must drop it if it
10441 * exists. This could happen if the user deleted 'plpgsql' and then
10442 * readded it, causing its oid to be greater than g_last_builtin_oid.
10443 */
10456 /*
10457 * Note that we're pushing extconfig (an OID array) back into
10458 * pg_extension exactly as-is. This is OK because pg_class OIDs are
10459 * preserved in binary upgrade.
10460 */
10463 else
10468 else
10474 {
10479 {
10483 }
10484 }
10487 }
10497 /* Dump Extension Comments and Security Labels */
10512 }
10514 /*
10515 * dumpType
10516 * writes out to fout the queries to recreate a user-defined type
10517 */
10518 static void
10520 {
10523 /* Skip if not to be dumped */
10527 /* Dump out in proper style */
10540 else
10543 }
10545 /*
10546 * dumpEnumType
10547 * writes out to fout the queries to recreate a user-defined enum type
10548 */
10549 static void
10551 {
10558 i;
10559 Oid enum_oid;
10566 "FROM pg_catalog.pg_enum "
10567 "WHERE enumtypid = '%u'"
10570 else
10572 "FROM pg_catalog.pg_enum "
10573 "WHERE enumtypid = '%u'"
10584 /*
10585 * CASCADE shouldn't be required here as for normal types since the I/O
10586 * functions are generic and do not get dropped.
10587 */
10596 qualtypname);
10599 {
10600 /* Labels with server-assigned oids */
10602 {
10608 }
10609 }
10614 {
10615 /* Labels with dump-assigned (preserved) oids */
10617 {
10625 enum_oid);
10629 }
10630 }
10647 /* Dump Type Comments and Security Labels */
10671 }
10673 /*
10674 * dumpRangeType
10675 * writes out to fout the queries to recreate a user-defined range type
10676 */
10677 static void
10679 {
10685 Oid collationOid;
10691 "SELECT pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
10692 "opc.opcname AS opcname, "
10693 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
10694 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
10695 "opc.opcdefault, "
10696 "CASE WHEN rngcollation = st.typcollation THEN 0 "
10697 " ELSE rngcollation END AS collation, "
10698 "rngcanonical, rngsubdiff "
10699 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
10700 " pg_catalog.pg_opclass opc "
10701 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
10710 /*
10711 * CASCADE shouldn't be required here as for normal types since the I/O
10712 * functions are generic and do not get dropped.
10713 */
10722 qualtypname);
10727 /* print subtype_opclass only if not default for subtype */
10729 {
10736 }
10740 {
10746 }
10773 /* Dump Type Comments and Security Labels */
10797 }
10799 /*
10800 * dumpUndefinedType
10801 * writes out to fout the queries to recreate a !typisdefined type
10802 *
10803 * This is a shell type, but we use different terminology to distinguish
10804 * this case from where we have to emit a shell type definition to break
10805 * circular dependencies. An undefined type shouldn't ever have anything
10806 * depending on it.
10807 */
10808 static void
10810 {
10828 qualtypname);
10845 /* Dump Type Comments and Security Labels */
10867 }
10869 /*
10870 * dumpBaseType
10871 * writes out to fout the queries to recreate a user-defined base type
10872 */
10873 static void
10875 {
10891 Oid typreceiveoid;
10892 Oid typsendoid;
10893 Oid typmodinoid;
10894 Oid typmodoutoid;
10895 Oid typanalyzeoid;
10906 /* Fetch type-specific details */
10908 {
10910 "typinput, typoutput, typreceive, typsend, "
10911 "typmodin, typmodout, typanalyze, "
10912 "typreceive::pg_catalog.oid AS typreceiveoid, "
10913 "typsend::pg_catalog.oid AS typsendoid, "
10914 "typmodin::pg_catalog.oid AS typmodinoid, "
10915 "typmodout::pg_catalog.oid AS typmodoutoid, "
10916 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
10917 "typcategory, typispreferred, "
10918 "typdelim, typbyval, typalign, typstorage, "
10919 "(typcollation <> 0) AS typcollatable, "
10920 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault "
10921 "FROM pg_catalog.pg_type "
10924 }
10926 {
10928 "typinput, typoutput, typreceive, typsend, "
10929 "typmodin, typmodout, typanalyze, "
10930 "typreceive::pg_catalog.oid AS typreceiveoid, "
10931 "typsend::pg_catalog.oid AS typsendoid, "
10932 "typmodin::pg_catalog.oid AS typmodinoid, "
10933 "typmodout::pg_catalog.oid AS typmodoutoid, "
10934 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
10935 "typcategory, typispreferred, "
10936 "typdelim, typbyval, typalign, typstorage, "
10937 "false AS typcollatable, "
10938 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault "
10939 "FROM pg_catalog.pg_type "
10942 }
10944 {
10945 /* Before 8.4, pg_get_expr does not allow 0 for its second arg */
10947 "typinput, typoutput, typreceive, typsend, "
10948 "typmodin, typmodout, typanalyze, "
10949 "typreceive::pg_catalog.oid AS typreceiveoid, "
10950 "typsend::pg_catalog.oid AS typsendoid, "
10951 "typmodin::pg_catalog.oid AS typmodinoid, "
10952 "typmodout::pg_catalog.oid AS typmodoutoid, "
10953 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
10954 "'U' AS typcategory, false AS typispreferred, "
10955 "typdelim, typbyval, typalign, typstorage, "
10956 "false AS typcollatable, "
10957 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
10958 "FROM pg_catalog.pg_type "
10961 }
10962 else
10963 {
10965 "typinput, typoutput, typreceive, typsend, "
10966 "'-' AS typmodin, '-' AS typmodout, "
10967 "typanalyze, "
10968 "typreceive::pg_catalog.oid AS typreceiveoid, "
10969 "typsend::pg_catalog.oid AS typsendoid, "
10970 "0 AS typmodinoid, 0 AS typmodoutoid, "
10971 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
10972 "'U' AS typcategory, false AS typispreferred, "
10973 "typdelim, typbyval, typalign, typstorage, "
10974 "false AS typcollatable, "
10975 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
10976 "FROM pg_catalog.pg_type "
10979 }
11006 {
11009 }
11010 else
11016 /*
11017 * The reason we include CASCADE is that the circular dependency between
11018 * the type and its I/O functions makes it impossible to drop the type any
11019 * other way.
11020 */
11023 /*
11024 * We might already have a shell type, but setting pg_type_oid is
11025 * harmless, and in any case we'd better set the array type OID.
11026 */
11035 qualtypname,
11038 /* regproc result is sufficiently quoted already */
11056 {
11060 else
11062 }
11067 zeroAsOpaque));
11070 {
11073 }
11079 {
11082 }
11122 /* Dump Type Comments and Security Labels */
11146 }
11148 /*
11149 * dumpDomain
11150 * writes out to fout the queries to recreate a user-defined domain
11151 */
11152 static void
11154 {
11166 Oid typcollation;
11169 /* Fetch domain specific details */
11171 {
11172 /* typcollation is new in 9.1 */
11174 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
11175 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
11176 "t.typdefault, "
11177 "CASE WHEN t.typcollation <> u.typcollation "
11178 "THEN t.typcollation ELSE 0 END AS typcollation "
11179 "FROM pg_catalog.pg_type t "
11180 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
11183 }
11184 else
11185 {
11187 "pg_catalog.format_type(typbasetype, typtypmod) AS typdefn, "
11188 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
11189 "typdefault, 0 AS typcollation "
11190 "FROM pg_catalog.pg_type "
11193 }
11202 {
11205 }
11206 else
11220 qualtypname,
11221 typdefn);
11223 /* Print collation only if different from base type's collation */
11225 {
11231 }
11237 {
11241 else
11243 }
11247 /*
11248 * Add any CHECK constraints for the domain
11249 */
11251 {
11257 }
11278 /* Dump Domain Comments and Security Labels */
11296 /* Dump any per-constraint comments */
11298 {
11312 }
11319 }
11321 /*
11322 * dumpCompositeType
11323 * writes out to fout the queries to recreate a user-defined stand-alone
11324 * composite type
11325 */
11326 static void
11328 {
11347 /* Fetch type specific details */
11349 {
11350 /*
11351 * attcollation is new in 9.1. Since we only want to dump COLLATE
11352 * clauses for attributes whose collation is different from their
11353 * type's default, we use a CASE here to suppress uninteresting
11354 * attcollations cheaply. atttypid will be 0 for dropped columns;
11355 * collation does not matter for those.
11356 */
11358 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
11359 "a.attlen, a.attalign, a.attisdropped, "
11360 "CASE WHEN a.attcollation <> at.typcollation "
11361 "THEN a.attcollation ELSE 0 END AS attcollation "
11362 "FROM pg_catalog.pg_type ct "
11363 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
11364 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
11365 "WHERE ct.oid = '%u'::pg_catalog.oid "
11368 }
11369 else
11370 {
11371 /*
11372 * Since ALTER TYPE could not drop columns until 9.1, attisdropped
11373 * should always be false.
11374 */
11376 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
11377 "a.attlen, a.attalign, a.attisdropped, "
11378 "0 AS attcollation "
11379 "FROM pg_catalog.pg_type ct, pg_catalog.pg_attribute a "
11380 "WHERE ct.oid = '%u'::pg_catalog.oid "
11381 "AND a.attrelid = ct.typrelid "
11384 }
11398 {
11403 }
11409 qualtypname);
11413 {
11419 Oid attcollation;
11431 /* Format properly if not first attr */
11437 {
11440 /* Add collation if not default for the column type */
11442 {
11449 }
11450 }
11451 else
11452 {
11453 /*
11454 * This is a dropped attribute and we're in binary_upgrade mode.
11455 * Insert a placeholder for it in the CREATE TYPE command, and set
11456 * length and alignment with direct UPDATE to the catalogs
11457 * afterwards. See similar code in dumpTableSchema().
11458 */
11461 /* stash separately for insertion after the CREATE TYPE */
11465 "SET attlen = %s, "
11474 qualtypname);
11477 }
11478 }
11500 /* Dump Type Comments and Security Labels */
11526 /* Dump any per-column comments */
11529 }
11531 /*
11532 * dumpCompositeTypeColComments
11533 * writes out to fout the queries to recreate comments on the columns of
11534 * a user-defined stand-alone composite type
11535 */
11536 static void
11538 {
11542 PQExpBuffer query;
11543 PQExpBuffer target;
11544 Oid pgClassOid;
11550 /* do nothing, if --no-comments is supplied */
11557 "SELECT c.tableoid, a.attname, a.attnum "
11558 "FROM pg_catalog.pg_class c, pg_catalog.pg_attribute a "
11559 "WHERE c.oid = '%u' AND c.oid = a.attrelid "
11560 " AND NOT a.attisdropped "
11564 /* Fetch column attnames */
11569 {
11573 }
11577 /* Search for comments associated with type's pg_class OID */
11579 pgClassOid,
11583 /* If no comments exist, we're done */
11585 {
11589 }
11591 /* Build COMMENT ON statements */
11597 {
11602 {
11604 {
11607 }
11608 }
11610 {
11634 }
11636 comments++;
11637 ncomments--;
11638 }
11643 }
11645 /*
11646 * dumpShellType
11647 * writes out to fout the queries to create a shell type
11648 *
11649 * We dump a shell definition in advance of the I/O functions for the type.
11650 */
11651 static void
11653 {
11655 PQExpBuffer q;
11657 /* Skip if not to be dumped */
11663 /*
11664 * Note the lack of a DROP command for the shell type; any required DROP
11665 * is driven off the base type entry, instead. This interacts with
11666 * _printTocEntry()'s use of the presence of a DROP command to decide
11667 * whether an entry needs an ALTER OWNER command. We don't want to alter
11668 * the shell type's owner immediately on creation; that should happen only
11669 * after it's filled in, otherwise the backend complains.
11670 */
11690 }
11692 /*
11693 * dumpProcLang
11694 * writes out to fout the queries to recreate a user-defined
11695 * procedural language
11696 */
11697 static void
11699 {
11701 PQExpBuffer defqry;
11702 PQExpBuffer delqry;
11709 /* Skip if not to be dumped */
11713 /*
11714 * Try to find the support function(s). It is not an error if we don't
11715 * find them --- if the functions are in the pg_catalog schema, as is
11716 * standard in 8.1 and up, then we won't have loaded them. (In this case
11717 * we will emit a parameterless CREATE LANGUAGE command, which will
11718 * require PL template knowledge in the backend to reload.)
11719 */
11726 {
11730 }
11733 {
11737 }
11739 /*
11740 * If the functions are dumpable then emit a traditional CREATE LANGUAGE
11741 * with parameters. Otherwise, we'll write a parameterless command, which
11742 * will rely on data from pg_pltemplate.
11743 */
11754 qlanname);
11757 {
11760 qlanname);
11769 }
11770 else
11771 {
11772 /*
11773 * If not dumping parameters, then use CREATE OR REPLACE so that the
11774 * command will not fail if the language is preinstalled in the target
11775 * database. We restrict the use of REPLACE to this case so as to
11776 * eliminate the risk of replacing a language with incompatible
11777 * parameter settings: this command will only succeed at all if there
11778 * is a pg_pltemplate entry, and if there is one, the existing entry
11779 * must match it too.
11780 */
11782 qlanname);
11783 }
11798 ));
11800 /* Dump Proc Lang Comments and Security Labels */
11821 }
11823 /*
11824 * format_function_arguments: generate function name and argument list
11825 *
11826 * This is used when we can rely on pg_get_function_arguments to format
11827 * the argument list. Note, however, that pg_get_function_arguments
11828 * does not special-case zero-argument aggregates.
11829 */
11832 {
11833 PQExpBufferData fn;
11839 else
11842 }
11844 /*
11845 * format_function_arguments_old: generate function name and argument list
11846 *
11847 * The argument type names are qualified if needed. The function name
11848 * is never qualified.
11849 *
11850 * This is used only with pre-8.4 servers, so we aren't expecting to see
11851 * VARIADIC or TABLE arguments, nor are there any defaults for arguments.
11852 *
11853 * Any or all of allargtypes, argmodes, argnames may be NULL.
11854 */
11861 {
11862 PQExpBufferData fn;
11868 {
11869 Oid typid;
11878 {
11880 {
11894 }
11895 }
11896 else
11905 argmode,
11908 typname);
11909 }
11912 }
11914 /*
11915 * format_function_signature: generate function name and argument list
11916 *
11917 * This is like format_function_arguments_old except that only a minimal
11918 * list of input argument types is generated; this is sufficient to
11919 * reference the function, but not to define it.
11920 *
11921 * If honor_quotes is false then the function name is never quoted.
11922 * This is appropriate for use in TOC tags, but not in SQL commands.
11923 */
11926 {
11927 PQExpBufferData fn;
11933 else
11936 {
11942 zeroAsOpaque));
11943 }
11946 }
11949 /*
11950 * dumpFunc:
11951 * dump out one function
11952 */
11953 static void
11955 {
11957 PQExpBuffer query;
11958 PQExpBuffer q;
11959 PQExpBuffer delqry;
11960 PQExpBuffer asPart;
11995 /* Skip if not to be dumped */
12004 /* Fetch function-specific details */
12006 {
12007 /*
12008 * prosupport was added in 12
12009 */
12011 "SELECT proretset, prosrc, probin, "
12012 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12013 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12014 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12015 "array_to_string(protrftypes, ' ') AS protrftypes, "
12016 "prokind, provolatile, proisstrict, prosecdef, "
12017 "proleakproof, proconfig, procost, prorows, "
12018 "prosupport, proparallel, "
12019 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12020 "FROM pg_catalog.pg_proc "
12023 }
12025 {
12026 /*
12027 * prokind was added in 11
12028 */
12030 "SELECT proretset, prosrc, probin, "
12031 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12032 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12033 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12034 "array_to_string(protrftypes, ' ') AS protrftypes, "
12035 "prokind, provolatile, proisstrict, prosecdef, "
12036 "proleakproof, proconfig, procost, prorows, "
12037 "'-' AS prosupport, proparallel, "
12038 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12039 "FROM pg_catalog.pg_proc "
12042 }
12044 {
12045 /*
12046 * proparallel was added in 9.6
12047 */
12049 "SELECT proretset, prosrc, probin, "
12050 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12051 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12052 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12053 "array_to_string(protrftypes, ' ') AS protrftypes, "
12054 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind, "
12055 "provolatile, proisstrict, prosecdef, "
12056 "proleakproof, proconfig, procost, prorows, "
12057 "'-' AS prosupport, proparallel, "
12058 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12059 "FROM pg_catalog.pg_proc "
12062 }
12064 {
12065 /*
12066 * protrftypes was added in 9.5
12067 */
12069 "SELECT proretset, prosrc, probin, "
12070 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12071 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12072 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12073 "array_to_string(protrftypes, ' ') AS protrftypes, "
12074 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind, "
12075 "provolatile, proisstrict, prosecdef, "
12076 "proleakproof, proconfig, procost, prorows, "
12077 "'-' AS prosupport, "
12078 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12079 "FROM pg_catalog.pg_proc "
12082 }
12084 {
12085 /*
12086 * proleakproof was added in 9.2
12087 */
12089 "SELECT proretset, prosrc, probin, "
12090 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12091 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12092 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12093 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind, "
12094 "provolatile, proisstrict, prosecdef, "
12095 "proleakproof, proconfig, procost, prorows, "
12096 "'-' AS prosupport, "
12097 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12098 "FROM pg_catalog.pg_proc "
12101 }
12103 {
12104 /*
12105 * In 8.4 and up we rely on pg_get_function_arguments and
12106 * pg_get_function_result instead of examining proallargtypes etc.
12107 */
12109 "SELECT proretset, prosrc, probin, "
12110 "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
12111 "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
12112 "pg_catalog.pg_get_function_result(oid) AS funcresult, "
12113 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind, "
12114 "provolatile, proisstrict, prosecdef, "
12115 "false AS proleakproof, "
12116 " proconfig, procost, prorows, "
12117 "'-' AS prosupport, "
12118 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12119 "FROM pg_catalog.pg_proc "
12122 }
12124 {
12126 "SELECT proretset, prosrc, probin, "
12127 "proallargtypes, proargmodes, proargnames, "
12128 "'f' AS prokind, "
12129 "provolatile, proisstrict, prosecdef, "
12130 "false AS proleakproof, "
12131 "proconfig, procost, prorows, "
12132 "'-' AS prosupport, "
12133 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12134 "FROM pg_catalog.pg_proc "
12137 }
12139 {
12141 "SELECT proretset, prosrc, probin, "
12142 "proallargtypes, proargmodes, proargnames, "
12143 "'f' AS prokind, "
12144 "provolatile, proisstrict, prosecdef, "
12145 "false AS proleakproof, "
12146 "null AS proconfig, 0 AS procost, 0 AS prorows, "
12147 "'-' AS prosupport, "
12148 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12149 "FROM pg_catalog.pg_proc "
12152 }
12153 else
12154 {
12156 "SELECT proretset, prosrc, probin, "
12157 "null AS proallargtypes, "
12158 "null AS proargmodes, "
12159 "proargnames, "
12160 "'f' AS prokind, "
12161 "provolatile, proisstrict, prosecdef, "
12162 "false AS proleakproof, "
12163 "null AS proconfig, 0 AS procost, 0 AS prorows, "
12164 "'-' AS prosupport, "
12165 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
12166 "FROM pg_catalog.pg_proc "
12169 }
12177 {
12182 }
12183 else
12184 {
12189 }
12192 else
12206 else
12211 /*
12212 * See backend/commands/functioncmds.c for details of how the 'AS' clause
12213 * is used. In 8.4 and up, an unused probin is NULL (here ""); previous
12214 * versions would set it to "-". There are no known cases in which prosrc
12215 * is unused, so the tests below for "-" are probably useless.
12216 */
12218 {
12222 {
12225 /*
12226 * where we have bin, use dollar quoting if allowed and src
12227 * contains quote or backslash; else use regular quoting.
12228 */
12232 else
12234 }
12235 }
12236 else
12237 {
12239 {
12241 /* with no bin, dollar quote src unconditionally if allowed */
12244 else
12246 }
12247 }
12252 {
12257 {
12262 }
12263 else
12265 }
12268 {
12273 {
12278 }
12279 }
12282 {
12287 {
12292 }
12293 }
12296 {
12298 {
12304 }
12305 }
12308 {
12309 /* 8.4 or later; we rely on server-side code for most of the work */
12312 }
12313 else
12314 /* pre-8.4, do it ourselves */
12323 else
12327 keyword,
12329 funcsig);
12332 keyword,
12335 funcsig);
12341 else
12345 zeroAsOpaque));
12350 {
12357 {
12362 }
12363 }
12369 {
12377 }
12388 /*
12389 * COST and ROWS are emitted only if present and not default, so as not to
12390 * break backwards-compatibility of the dump without need. Keep this code
12391 * in sync with the defaults in functioncmds.c.
12392 */
12394 {
12396 {
12397 /* default cost is 1 */
12400 }
12401 else
12402 {
12403 /* default cost is 100 */
12406 }
12407 }
12413 {
12414 /* We rely on regprocout to provide quoting and qualification */
12416 }
12419 {
12427 }
12430 {
12431 /* we feel free to scribble on configitems[] here */
12441 /*
12442 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
12443 * by flatten_set_variable_args() before they were put into the
12444 * proconfig array. However, because the quoting rules used there
12445 * aren't exactly like SQL's, we have to break the list value apart
12446 * and then quote the elements as string literals. (The elements may
12447 * be double-quoted as-is, but we can't just feed them to the SQL
12448 * parser; it would do the wrong thing with elements that are
12449 * zero-length or longer than NAMEDATALEN.)
12450 *
12451 * Variables that are not so marked should just be emitted as simple
12452 * string literals. If the variable is not known to
12453 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
12454 * to use GUC_LIST_QUOTE for extension variables.
12455 */
12457 {
12461 /* Parse string into list of identifiers */
12462 /* this shouldn't fail really */
12464 {
12466 {
12470 }
12471 }
12473 }
12474 else
12476 }
12484 funcsig));
12501 /* Dump Function Comments and Security Labels */
12537 }
12540 /*
12541 * Dump a user-defined cast
12542 */
12543 static void
12545 {
12547 PQExpBuffer defqry;
12548 PQExpBuffer delqry;
12549 PQExpBuffer labelq;
12550 PQExpBuffer castargs;
12555 /* Skip if not to be dumped */
12559 /* Cannot dump if we don't have the cast function's info */
12561 {
12566 }
12582 {
12591 {
12594 /*
12595 * Always qualify the function name (format_function_signature
12596 * won't qualify it).
12597 */
12601 }
12602 else
12607 }
12633 /* Dump Cast Comments */
12643 }
12645 /*
12646 * Dump a transform
12647 */
12648 static void
12650 {
12652 PQExpBuffer defqry;
12653 PQExpBuffer delqry;
12654 PQExpBuffer labelq;
12655 PQExpBuffer transformargs;
12661 /* Skip if not to be dumped */
12665 /* Cannot dump if we don't have the transform functions' info */
12667 {
12672 }
12674 {
12679 }
12696 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
12699 {
12701 {
12704 /*
12705 * Always qualify the function name (format_function_signature
12706 * won't qualify it).
12707 */
12711 }
12712 else
12714 }
12717 {
12722 {
12725 /*
12726 * Always qualify the function name (format_function_signature
12727 * won't qualify it).
12728 */
12732 }
12733 else
12735 }
12759 /* Dump Transform Comments */
12770 }
12773 /*
12774 * dumpOpr
12775 * write out a single operator definition
12776 */
12777 static void
12779 {
12781 PQExpBuffer query;
12782 PQExpBuffer q;
12783 PQExpBuffer delq;
12784 PQExpBuffer oprid;
12785 PQExpBuffer details;
12810 /* Skip if not to be dumped */
12814 /*
12815 * some operators are invalid because they were the result of user
12816 * defining operators before commutators exist
12817 */
12828 {
12830 "oprcode::pg_catalog.regprocedure, "
12831 "oprleft::pg_catalog.regtype, "
12832 "oprright::pg_catalog.regtype, "
12833 "oprcom, "
12834 "oprnegate, "
12835 "oprrest::pg_catalog.regprocedure, "
12836 "oprjoin::pg_catalog.regprocedure, "
12837 "oprcanmerge, oprcanhash "
12838 "FROM pg_catalog.pg_operator "
12841 }
12842 else
12843 {
12845 "oprcode::pg_catalog.regprocedure, "
12846 "oprleft::pg_catalog.regtype, "
12847 "oprright::pg_catalog.regtype, "
12848 "oprcom, "
12849 "oprnegate, "
12850 "oprrest::pg_catalog.regprocedure, "
12851 "oprjoin::pg_catalog.regprocedure, "
12852 "(oprlsortop != 0) AS oprcanmerge, "
12853 "oprcanhash "
12854 "FROM pg_catalog.pg_operator "
12857 }
12885 {
12888 }
12893 /*
12894 * right unary means there's a left arg and left unary means there's a
12895 * right arg
12896 */
12899 {
12902 }
12903 else
12908 {
12911 }
12912 else
12917 {
12920 }
12924 {
12927 }
12937 {
12940 }
12944 {
12947 }
12972 /* Dump Operator Comments */
12985 }
12987 /*
12988 * Convert a function reference obtained from pg_operator
12989 *
12990 * Returns allocated string of what to print, or NULL if function references
12991 * is InvalidOid. Returned string is expected to be free'd by the caller.
12992 *
12993 * The input is a REGPROCEDURE display; we have to strip the argument-types
12994 * part.
12995 */
12998 {
13003 /* In all cases "-" means a null reference */
13008 /* find non-double-quoted left paren */
13011 {
13013 {
13016 }
13019 }
13021 }
13023 /*
13024 * getFormattedOperatorName - retrieve the operator name for the
13025 * given operator OID (presented in string form).
13026 *
13027 * Returns an allocated string, or NULL if the given OID is invalid.
13028 * Caller is responsible for free'ing result string.
13029 *
13030 * What we produce has the format "OPERATOR(schema.oprname)". This is only
13031 * useful in commands where the operator's argument types can be inferred from
13032 * context. We always schema-qualify the name, though. The predecessor to
13033 * this code tried to skip the schema qualification if possible, but that led
13034 * to wrong results in corner cases, such as if an operator and its negator
13035 * are in different schemas.
13036 */
13039 {
13042 /* In all cases "0" means a null reference */
13048 {
13050 oproid);
13052 }
13057 }
13059 /*
13060 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
13061 *
13062 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
13063 * argument lists of these functions are predetermined. Note that the
13064 * caller should ensure we are in the proper schema, because the results
13065 * are search path dependent!
13066 */
13069 {
13083 }
13085 /*
13086 * dumpAccessMethod
13087 * write out a single access method definition
13088 */
13089 static void
13091 {
13093 PQExpBuffer q;
13094 PQExpBuffer delq;
13097 /* Skip if not to be dumped */
13109 {
13123 }
13128 qamname);
13142 /* Dump Access Method Comments */
13151 }
13153 /*
13154 * dumpOpclass
13155 * write out a single operator class definition
13156 */
13157 static void
13159 {
13161 PQExpBuffer query;
13162 PQExpBuffer q;
13163 PQExpBuffer delq;
13164 PQExpBuffer nameusing;
13202 /* Skip if not to be dumped */
13211 /* Get additional fields from the pg_opclass row */
13213 {
13215 "opckeytype::pg_catalog.regtype, "
13216 "opcdefault, opcfamily, "
13217 "opfname AS opcfamilyname, "
13218 "nspname AS opcfamilynsp, "
13219 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
13220 "FROM pg_catalog.pg_opclass c "
13221 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
13222 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13225 }
13226 else
13227 {
13229 "opckeytype::pg_catalog.regtype, "
13230 "opcdefault, NULL AS opcfamily, "
13231 "NULL AS opcfamilyname, "
13232 "NULL AS opcfamilynsp, "
13233 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcamid) AS amname "
13234 "FROM pg_catalog.pg_opclass "
13237 }
13249 /* opcintype may still be needed after we PQclear res */
13253 /* opcfamily will still be needed after we PQclear res */
13257 /* amname will still be needed after we PQclear res */
13265 /* Build the fixed portion of the CREATE command */
13271 opcintype,
13274 {
13278 }
13284 {
13286 opckeytype);
13288 }
13292 /*
13293 * Now fetch and print the OPERATOR entries (pg_amop rows).
13294 *
13295 * Print only those opfamily members that are tied to the opclass by
13296 * pg_depend entries.
13297 *
13298 * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping an
13299 * older server's opclass in which it is used. This is to avoid
13300 * hard-to-detect breakage if a newer pg_dump is used to dump from an
13301 * older server and then reload into that old version. This can go away
13302 * once 8.3 is so old as to not be of interest to anyone.
13303 */
13307 {
13309 "amopopr::pg_catalog.regoperator, "
13310 "opfname AS sortfamily, "
13311 "nspname AS sortfamilynsp "
13312 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13313 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13314 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13315 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13316 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13317 "AND refobjid = '%u'::pg_catalog.oid "
13318 "AND amopfamily = '%s'::pg_catalog.oid "
13321 opcfamily);
13322 }
13324 {
13326 "amopopr::pg_catalog.regoperator, "
13327 "NULL AS sortfamily, "
13328 "NULL AS sortfamilynsp "
13329 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
13330 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13331 "AND refobjid = '%u'::pg_catalog.oid "
13332 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
13333 "AND objid = ao.oid "
13336 }
13338 {
13340 "amopopr::pg_catalog.regoperator, "
13341 "NULL AS sortfamily, "
13342 "NULL AS sortfamilynsp "
13343 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
13344 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13345 "AND refobjid = '%u'::pg_catalog.oid "
13346 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
13347 "AND objid = ao.oid "
13350 }
13351 else
13352 {
13353 /*
13354 * Here, we print all entries since there are no opfamilies and hence
13355 * no loose operators to worry about.
13356 */
13358 "amopopr::pg_catalog.regoperator, "
13359 "NULL AS sortfamily, "
13360 "NULL AS sortfamilynsp "
13361 "FROM pg_catalog.pg_amop "
13362 "WHERE amopclaid = '%u'::pg_catalog.oid "
13365 }
13378 {
13392 {
13396 }
13402 }
13406 /*
13407 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13408 *
13409 * Print only those opfamily members that are tied to the opclass by
13410 * pg_depend entries.
13411 *
13412 * We print the amproclefttype/amprocrighttype even though in most cases
13413 * the backend could deduce the right values, because of the corner case
13414 * of a btree sort support function for a cross-type comparison. That's
13415 * only allowed in 9.2 and later, but for simplicity print them in all
13416 * versions that have the columns.
13417 */
13421 {
13423 "amproc::pg_catalog.regprocedure, "
13424 "amproclefttype::pg_catalog.regtype, "
13425 "amprocrighttype::pg_catalog.regtype "
13426 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13427 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
13428 "AND refobjid = '%u'::pg_catalog.oid "
13429 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13430 "AND objid = ap.oid "
13433 }
13434 else
13435 {
13437 "amproc::pg_catalog.regprocedure, "
13438 "'' AS amproclefttype, "
13439 "'' AS amprocrighttype "
13440 "FROM pg_catalog.pg_amproc "
13441 "WHERE amopclaid = '%u'::pg_catalog.oid "
13444 }
13456 {
13473 }
13477 /*
13478 * If needComma is still false it means we haven't added anything after
13479 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
13480 * clause with the same datatype. This isn't sanctioned by the
13481 * documentation, but actually DefineOpClass will treat it as a no-op.
13482 */
13507 /* Dump Operator Class Comments */
13520 }
13522 /*
13523 * dumpOpfamily
13524 * write out a single operator family definition
13525 *
13526 * Note: this also dumps any "loose" operator members that aren't bound to a
13527 * specific opclass within the opfamily.
13528 */
13529 static void
13531 {
13533 PQExpBuffer query;
13534 PQExpBuffer q;
13535 PQExpBuffer delq;
13536 PQExpBuffer nameusing;
13564 /* Skip if not to be dumped */
13573 /*
13574 * Fetch only those opfamily members that are tied directly to the
13575 * opfamily by pg_depend entries.
13576 *
13577 * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping an
13578 * older server's opclass in which it is used. This is to avoid
13579 * hard-to-detect breakage if a newer pg_dump is used to dump from an
13580 * older server and then reload into that old version. This can go away
13581 * once 8.3 is so old as to not be of interest to anyone.
13582 */
13584 {
13586 "amopopr::pg_catalog.regoperator, "
13587 "opfname AS sortfamily, "
13588 "nspname AS sortfamilynsp "
13589 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
13590 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
13591 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
13592 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
13593 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13594 "AND refobjid = '%u'::pg_catalog.oid "
13595 "AND amopfamily = '%u'::pg_catalog.oid "
13599 }
13601 {
13603 "amopopr::pg_catalog.regoperator, "
13604 "NULL AS sortfamily, "
13605 "NULL AS sortfamilynsp "
13606 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
13607 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13608 "AND refobjid = '%u'::pg_catalog.oid "
13609 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
13610 "AND objid = ao.oid "
13613 }
13614 else
13615 {
13617 "amopopr::pg_catalog.regoperator, "
13618 "NULL AS sortfamily, "
13619 "NULL AS sortfamilynsp "
13620 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
13621 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13622 "AND refobjid = '%u'::pg_catalog.oid "
13623 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
13624 "AND objid = ao.oid "
13627 }
13634 "amproc::pg_catalog.regprocedure, "
13635 "amproclefttype::pg_catalog.regtype, "
13636 "amprocrighttype::pg_catalog.regtype "
13637 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
13638 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
13639 "AND refobjid = '%u'::pg_catalog.oid "
13640 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
13641 "AND objid = ap.oid "
13647 /* Get additional fields from the pg_opfamily row */
13651 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
13652 "FROM pg_catalog.pg_opfamily "
13660 /* amname will still be needed after we PQclear res */
13668 /* Build the fixed portion of the CREATE command */
13676 /* Do we need an ALTER to add loose members? */
13678 {
13686 /*
13687 * Now fetch and print the OPERATOR entries (pg_amop rows).
13688 */
13698 {
13712 {
13716 }
13722 }
13724 /*
13725 * Now fetch and print the FUNCTION entries (pg_amproc rows).
13726 */
13735 {
13746 amproc);
13749 }
13752 }
13773 /* Dump Operator Family Comments */
13786 }
13788 /*
13789 * dumpCollation
13790 * write out a single collation definition
13791 */
13792 static void
13794 {
13796 PQExpBuffer query;
13797 PQExpBuffer q;
13798 PQExpBuffer delq;
13809 /* Skip if not to be dumped */
13819 /* Get collation-specific details */
13824 "collprovider, "
13826 else
13828 "'c' AS collprovider, "
13834 else
13839 "collcollate, "
13840 "collctype "
13841 "FROM pg_catalog.pg_collation c "
13868 /* to allow dumping pg_catalog; not accepted on input */
13870 else
13872 collprovider);
13878 {
13881 }
13882 else
13883 {
13888 }
13890 /*
13891 * For binary upgrade, carry over the collation version. For normal
13892 * dump/restore, omit the version, so that it is computed upon restore.
13893 */
13895 {
13900 {
13904 fout);
13905 }
13906 }
13925 /* Dump Collation Comments */
13937 }
13939 /*
13940 * dumpConversion
13941 * write out a single conversion definition
13942 */
13943 static void
13945 {
13947 PQExpBuffer query;
13948 PQExpBuffer q;
13949 PQExpBuffer delq;
13961 /* Skip if not to be dumped */
13971 /* Get conversion-specific details */
13973 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
13974 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
13975 "conproc, condefault "
13976 "FROM pg_catalog.pg_conversion c "
14001 /* regproc output is already sufficiently quoted */
14019 /* Dump Conversion Comments */
14031 }
14033 /*
14034 * format_aggregate_signature: generate aggregate name and argument list
14035 *
14036 * The argument type names are qualified if needed. The aggregate name
14037 * is never qualified.
14038 */
14041 {
14042 PQExpBufferData buf;
14048 else
14053 else
14054 {
14061 zeroAsOpaque));
14063 }
14065 }
14067 /*
14068 * dumpAgg
14069 * write out a single aggregate definition
14070 */
14071 static void
14073 {
14075 PQExpBuffer query;
14076 PQExpBuffer q;
14077 PQExpBuffer delq;
14078 PQExpBuffer details;
14130 /* Skip if not to be dumped */
14139 /* Get aggregate-specific details */
14141 {
14143 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14144 "aggcombinefn, aggserialfn, aggdeserialfn, aggmtransfn, "
14145 "aggminvtransfn, aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
14146 "aggfinalextra, aggmfinalextra, "
14147 "aggfinalmodify, aggmfinalmodify, "
14148 "aggsortop, "
14149 "aggkind, "
14150 "aggtransspace, agginitval, "
14151 "aggmtransspace, aggminitval, "
14152 "true AS convertok, "
14153 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs, "
14154 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs, "
14155 "p.proparallel "
14156 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14157 "WHERE a.aggfnoid = p.oid "
14160 }
14162 {
14164 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14165 "aggcombinefn, aggserialfn, aggdeserialfn, aggmtransfn, "
14166 "aggminvtransfn, aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
14167 "aggfinalextra, aggmfinalextra, "
14168 "'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
14169 "aggsortop, "
14170 "aggkind, "
14171 "aggtransspace, agginitval, "
14172 "aggmtransspace, aggminitval, "
14173 "true AS convertok, "
14174 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs, "
14175 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs, "
14176 "p.proparallel "
14177 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14178 "WHERE a.aggfnoid = p.oid "
14181 }
14183 {
14185 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14186 "'-' AS aggcombinefn, '-' AS aggserialfn, "
14187 "'-' AS aggdeserialfn, aggmtransfn, aggminvtransfn, "
14188 "aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
14189 "aggfinalextra, aggmfinalextra, "
14190 "'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
14191 "aggsortop, "
14192 "aggkind, "
14193 "aggtransspace, agginitval, "
14194 "aggmtransspace, aggminitval, "
14195 "true AS convertok, "
14196 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs, "
14197 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs "
14198 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14199 "WHERE a.aggfnoid = p.oid "
14202 }
14204 {
14206 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14207 "'-' AS aggcombinefn, '-' AS aggserialfn, "
14208 "'-' AS aggdeserialfn, '-' AS aggmtransfn, "
14209 "'-' AS aggminvtransfn, '-' AS aggmfinalfn, "
14210 "0 AS aggmtranstype, false AS aggfinalextra, "
14211 "false AS aggmfinalextra, "
14212 "'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
14213 "aggsortop, "
14214 "'n' AS aggkind, "
14215 "0 AS aggtransspace, agginitval, "
14216 "0 AS aggmtransspace, NULL AS aggminitval, "
14217 "true AS convertok, "
14218 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs, "
14219 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs "
14220 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14221 "WHERE a.aggfnoid = p.oid "
14224 }
14226 {
14228 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14229 "'-' AS aggcombinefn, '-' AS aggserialfn, "
14230 "'-' AS aggdeserialfn, '-' AS aggmtransfn, "
14231 "'-' AS aggminvtransfn, '-' AS aggmfinalfn, "
14232 "0 AS aggmtranstype, false AS aggfinalextra, "
14233 "false AS aggmfinalextra, "
14234 "'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
14235 "aggsortop, "
14236 "'n' AS aggkind, "
14237 "0 AS aggtransspace, agginitval, "
14238 "0 AS aggmtransspace, NULL AS aggminitval, "
14239 "true AS convertok "
14240 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14241 "WHERE a.aggfnoid = p.oid "
14244 }
14245 else
14246 {
14248 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
14249 "'-' AS aggcombinefn, '-' AS aggserialfn, "
14250 "'-' AS aggdeserialfn, '-' AS aggmtransfn, "
14251 "'-' AS aggminvtransfn, '-' AS aggmfinalfn, "
14252 "0 AS aggmtranstype, false AS aggfinalextra, "
14253 "false AS aggmfinalextra, "
14254 "'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
14255 "0 AS aggsortop, "
14256 "'n' AS aggkind, "
14257 "0 AS aggtransspace, agginitval, "
14258 "0 AS aggmtransspace, NULL AS aggminitval, "
14259 "true AS convertok "
14260 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
14261 "WHERE a.aggfnoid = p.oid "
14264 }
14314 {
14315 /* 8.4 or later; we rely on server-side code for most of the work */
14323 }
14324 else
14325 /* pre-8.4, do it ourselves */
14332 else
14336 {
14337 pg_log_warning("aggregate function %s could not be dumped correctly for this database version; ignored",
14338 aggsig);
14346 }
14348 /* identify default modify flag for aggkind (must match DefineAggregate) */
14349 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
14350 /* replace omitted flags for old versions */
14356 /* regproc and regtype output is already sufficiently quoted */
14361 {
14363 aggtransspace);
14364 }
14367 {
14370 }
14373 {
14375 aggfinalfn);
14379 {
14381 {
14395 }
14396 }
14397 }
14409 {
14411 aggmtransfn,
14412 aggminvtransfn,
14413 aggmtranstype);
14414 }
14417 {
14419 aggmtransspace);
14420 }
14423 {
14426 }
14429 {
14431 aggmfinalfn);
14435 {
14437 {
14451 }
14452 }
14453 }
14457 {
14459 aggsortconvop);
14461 }
14467 {
14475 }
14479 aggsig);
14501 /* Dump Aggregate Comments */
14514 /*
14515 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
14516 * command look like a function's GRANT; in particular this affects the
14517 * syntax for zero-argument aggregates and ordered-set aggregates.
14518 */
14542 }
14544 /*
14545 * dumpTSParser
14546 * write out a single text search parser
14547 */
14548 static void
14550 {
14552 PQExpBuffer q;
14553 PQExpBuffer delq;
14556 /* Skip if not to be dumped */
14597 /* Dump Parser Comments */
14606 }
14608 /*
14609 * dumpTSDictionary
14610 * write out a single text search dictionary
14611 */
14612 static void
14614 {
14616 PQExpBuffer q;
14617 PQExpBuffer delq;
14618 PQExpBuffer query;
14624 /* Skip if not to be dumped */
14634 /* Fetch name and namespace of the dictionary's template */
14636 "FROM pg_ts_template p, pg_namespace n "
14652 /* the dictinitoption can be dumped straight into the command */
14676 /* Dump Dictionary Comments */
14686 }
14688 /*
14689 * dumpTSTemplate
14690 * write out a single text search template
14691 */
14692 static void
14694 {
14696 PQExpBuffer q;
14697 PQExpBuffer delq;
14700 /* Skip if not to be dumped */
14735 /* Dump Template Comments */
14744 }
14746 /*
14747 * dumpTSConfig
14748 * write out a single text search configuration
14749 */
14750 static void
14752 {
14754 PQExpBuffer q;
14755 PQExpBuffer delq;
14756 PQExpBuffer query;
14762 i;
14766 /* Skip if not to be dumped */
14776 /* Fetch name and namespace of the config's parser */
14778 "FROM pg_ts_parser p, pg_namespace n "
14811 {
14817 {
14818 /* starting a new token type, so start a new command */
14823 /* tokenname needs quoting, dictname does NOT */
14826 }
14827 else
14829 }
14854 /* Dump Configuration Comments */
14864 }
14866 /*
14867 * dumpForeignDataWrapper
14868 * write out a single foreign-data wrapper definition
14869 */
14870 static void
14872 {
14874 PQExpBuffer q;
14875 PQExpBuffer delq;
14878 /* Skip if not to be dumped */
14888 qfdwname);
14902 qfdwname);
14907 NULL);
14918 /* Dump Foreign Data Wrapper Comments */
14924 /* Handle the ACL */
14936 }
14938 /*
14939 * dumpForeignServer
14940 * write out a foreign server definition
14941 */
14942 static void
14944 {
14946 PQExpBuffer q;
14947 PQExpBuffer delq;
14948 PQExpBuffer query;
14953 /* Skip if not to be dumped */
14963 /* look up the foreign-data wrapper */
14965 "FROM pg_foreign_data_wrapper w "
14973 {
14976 }
14978 {
14981 }
14992 qsrvname);
15007 /* Dump Foreign Server Comments */
15013 /* Handle the ACL */
15021 /* Dump user mappings */
15033 }
15035 /*
15036 * dumpUserMappings
15037 *
15038 * This routine is used to dump any user mappings associated with the
15039 * server handed to this routine. Should be called after ArchiveEntry()
15040 * for the server.
15041 */
15042 static void
15047 {
15048 PQExpBuffer q;
15049 PQExpBuffer delq;
15050 PQExpBuffer query;
15051 PQExpBuffer tag;
15063 /*
15064 * We read from the publicly accessible view pg_user_mappings, so as not
15065 * to fail if run by a non-superuser. Note that the view will show
15066 * umoptions as null if the user hasn't got privileges for the associated
15067 * server; this means that pg_dump will dump such a mapping, but with no
15068 * OPTIONS clause. A possible alternative is to skip such mappings
15069 * altogether, but it's not clear that that's an improvement.
15070 */
15072 "SELECT usename, "
15073 "array_to_string(ARRAY("
15074 "SELECT quote_ident(option_name) || ' ' || "
15075 "quote_literal(option_value) "
15076 "FROM pg_options_to_table(umoptions) "
15077 "ORDER BY option_name"
15079 "FROM pg_user_mappings "
15080 "WHERE srvid = '%u' "
15091 {
15123 }
15131 }
15133 /*
15134 * Write out default privileges information
15135 */
15136 static void
15138 {
15140 PQExpBuffer q;
15141 PQExpBuffer tag;
15144 /* Skip if not to be dumped */
15152 {
15169 /* shouldn't get here */
15173 }
15177 /* build the actual command(s) for this tuple */
15187 q))
15203 }
15205 /*----------
15206 * Write out grant/revoke information
15207 *
15208 * 'objDumpId' is the dump ID of the underlying object.
15209 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
15210 * or InvalidDumpId if there is no need for a second dependency.
15211 * 'type' must be one of
15212 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
15213 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
15214 * 'name' is the formatted name of the object. Must be quoted etc. already.
15215 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
15216 * (Currently we assume that subname is only provided for table columns.)
15217 * 'nspname' is the namespace the object is in (NULL if none).
15218 * 'owner' is the owner, NULL if there is no owner (for languages).
15219 * 'acls' contains the ACL string of the object from the appropriate system
15220 * catalog field; it will be passed to buildACLCommands for building the
15221 * appropriate GRANT commands.
15222 * 'racls' contains the ACL string of any initial-but-now-revoked ACLs of the
15223 * object; it will be passed to buildACLCommands for building the
15224 * appropriate REVOKE commands.
15225 * 'initacls' In binary-upgrade mode, ACL string of the object's initial
15226 * privileges, to be recorded into pg_init_privs
15227 * 'initracls' In binary-upgrade mode, ACL string of the object's
15228 * revoked-from-default privileges, to be recorded into pg_init_privs
15229 *
15230 * NB: initacls/initracls are needed because extensions can set privileges on
15231 * an object during the extension's script file and we record those into
15232 * pg_init_privs as that object's initial privileges.
15233 *
15234 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
15235 * no ACL entry was created.
15236 *----------
15237 */
15238 static DumpId
15244 {
15247 PQExpBuffer sql;
15249 /* Do nothing if ACL dump is not enabled */
15253 /* --data-only skips ACLs *except* BLOB ACLs */
15259 /*
15260 * Check to see if this object has had any initial ACLs included for it.
15261 * If so, we are in binary upgrade mode and these are the ACLs to turn
15262 * into GRANT and REVOKE statements to set and record the initial
15263 * privileges for an extension object. Let the backend know that these
15264 * are to be recorded by calling binary_upgrade_set_record_init_privs()
15265 * before and after.
15266 */
15268 {
15273 fatal("could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)",
15276 }
15285 {
15292 else
15312 }
15317 }
15319 /*
15320 * dumpSecLabel
15321 *
15322 * This routine is used to dump any security labels associated with the
15323 * object handed to this routine. The routine takes the object type
15324 * and object name (ready to print, except for schema decoration), plus
15325 * the namespace and owner of the object (for labeling the ArchiveEntry),
15326 * plus catalog ID and subid which are the lookup key for pg_seclabel,
15327 * plus the dump ID for the object (for setting a dependency).
15328 * If a matching pg_seclabel entry is found, it is dumped.
15329 *
15330 * Note: although this routine takes a dumpId for dependency purposes,
15331 * that purpose is just to mark the dependency in the emitted dump file
15332 * for possible future use by pg_restore. We do NOT use it for determining
15333 * ordering of the label in the dump file, because this routine is called
15334 * after dependency sorting occurs. This routine should be called just after
15335 * calling ArchiveEntry() for the specified object.
15336 */
15337 static void
15341 {
15346 PQExpBuffer query;
15348 /* do nothing, if --no-security-labels is supplied */
15352 /* Security labels are schema not data ... except blob labels are data */
15354 {
15357 }
15358 else
15359 {
15360 /* We do dump blob security labels in binary-upgrade mode */
15363 }
15365 /* Search for security labels associated with catalogId, using table */
15371 {
15372 /*
15373 * Ignore label entries for which the subid doesn't match.
15374 */
15386 }
15389 {
15403 }
15406 }
15408 /*
15409 * dumpTableSecLabel
15410 *
15411 * As above, but dump security label for both the specified table (or view)
15412 * and its columns.
15413 */
15414 static void
15416 {
15421 PQExpBuffer query;
15422 PQExpBuffer target;
15424 /* do nothing, if --no-security-labels is supplied */
15428 /* SecLabel are SCHEMA not data */
15432 /* Search for comments associated with relation, using table */
15438 /* If security labels exist, build SECURITY LABEL statements */
15446 {
15454 {
15457 }
15458 else
15459 {
15461 /* first fmtXXX result must be consumed before calling again */
15465 }
15470 }
15472 {
15485 }
15488 }
15490 /*
15491 * findSecLabels
15492 *
15493 * Find the security label(s), if any, associated with the given object.
15494 * All the objsubid values associated with the given classoid/objoid are
15495 * found with one search.
15496 */
15497 static int
15499 {
15500 /* static storage for table of security labels */
15509 /* Get security labels if we didn't already */
15514 {
15517 }
15519 /*
15520 * Do binary search to find some item matching the object.
15521 */
15525 {
15536 else
15538 }
15541 {
15544 }
15546 /*
15547 * Now determine how many items match the object. The search loop
15548 * invariant still holds: only items between low and high inclusive could
15549 * match.
15550 */
15553 {
15557 middle--;
15558 nmatch++;
15559 }
15565 {
15569 middle++;
15570 nmatch++;
15571 }
15574 }
15576 /*
15577 * collectSecLabels
15578 *
15579 * Construct a table of all security labels available for database objects.
15580 * It's much faster to pull them all at once.
15581 *
15582 * The table is sorted by classoid/objid/objsubid for speed in lookup.
15583 */
15584 static int
15586 {
15588 PQExpBuffer query;
15601 "SELECT label, provider, classoid, objoid, objsubid "
15602 "FROM pg_catalog.pg_seclabel "
15607 /* Construct lookup table containing OIDs in numeric form */
15619 {
15625 }
15627 /* Do NOT free the PGresult since we are keeping pointers into it */
15632 }
15634 /*
15635 * dumpTable
15636 * write out to fout the declarations (not data) of a user-defined table
15637 */
15638 static void
15640 {
15645 /*
15646 * noop if we are not dumping anything about this table, or if we are
15647 * doing a data-only dump
15648 */
15654 else
15657 /* Handle the ACL here */
15660 {
15664 tableAclDumpId =
15670 }
15672 /*
15673 * Handle column ACLs, if any. Note: we pull these with a separate query
15674 * rather than trying to fetch them during getTableAttrs, so that we won't
15675 * miss ACLs on system columns.
15676 */
15678 {
15684 {
15695 "SELECT at.attname, "
15696 "%s AS attacl, "
15697 "%s AS rattacl, "
15698 "%s AS initattacl, "
15699 "%s AS initrattacl "
15700 "FROM pg_catalog.pg_attribute at "
15701 "JOIN pg_catalog.pg_class c ON (at.attrelid = c.oid) "
15702 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
15703 "(at.attrelid = pip.objoid "
15704 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
15705 "AND at.attnum = pip.objsubid) "
15706 "WHERE at.attrelid = '%u'::pg_catalog.oid AND "
15707 "NOT at.attisdropped "
15708 "AND ("
15709 "%s IS NOT NULL OR "
15710 "%s IS NOT NULL OR "
15711 "%s IS NOT NULL OR "
15712 "%s IS NOT NULL)"
15728 }
15729 else
15730 {
15732 "SELECT attname, attacl, NULL as rattacl, "
15733 "NULL AS initattacl, NULL AS initrattacl "
15734 "FROM pg_catalog.pg_attribute "
15735 "WHERE attrelid = '%u'::pg_catalog.oid AND NOT attisdropped "
15736 "AND attacl IS NOT NULL "
15739 }
15744 {
15754 /*
15755 * Column's GRANT type is always TABLE. Each column ACL depends
15756 * on the table-level ACL, since we can restore column ACLs in
15757 * parallel but the table-level ACL has to be done first.
15758 */
15764 }
15767 }
15772 }
15774 /*
15775 * Create the AS clause for a view or materialized view. The semicolon is
15776 * stripped because a materialized view must add a WITH NO DATA clause.
15777 *
15778 * This returns a new buffer which must be freed by the caller.
15779 */
15780 static PQExpBuffer
15782 {
15788 /* Fetch the view definition */
15796 {
15800 else
15803 }
15811 /* Strip off the trailing semicolon so that other things may follow. */
15819 }
15821 /*
15822 * Create a dummy AS clause for a view. This is used when the real view
15823 * definition has to be postponed because of circular dependencies.
15824 * We must duplicate the view's external properties -- column names and types
15825 * (including collation) -- so that it works for subsequent references.
15826 *
15827 * This returns a new buffer which must be freed by the caller.
15828 */
15829 static PQExpBuffer
15831 {
15838 {
15845 /*
15846 * Must add collation if not default for the type, because CREATE OR
15847 * REPLACE VIEW won't change it
15848 */
15850 {
15857 }
15860 }
15863 }
15865 /*
15866 * dumpTableSchema
15867 * write the declaration (not data) of one user-defined table or view
15868 */
15869 static void
15871 {
15883 k;
15885 /* We had better have loaded per-column details about this table */
15893 qrelname);
15899 /* Is it a table or a view? */
15901 {
15902 PQExpBuffer result;
15904 /*
15905 * Note: keep this code in sync with the is_view case in dumpRule()
15906 */
15920 else
15921 {
15923 {
15927 }
15929 }
15936 }
15937 else
15938 {
15943 /*
15944 * Set reltypename, and collect any relkind-specific data that we
15945 * didn't fetch during getTables().
15946 */
15948 {
15950 {
15956 /* retrieve partition key definition */
15965 }
15967 {
15975 /* retrieve name of foreign server and generic options */
15977 "SELECT fs.srvname, "
15978 "pg_catalog.array_to_string(ARRAY("
15979 "SELECT pg_catalog.quote_ident(option_name) || "
15980 "' ' || pg_catalog.quote_literal(option_value) "
15981 "FROM pg_catalog.pg_options_to_table(ftoptions) "
15982 "ORDER BY option_name"
15984 "FROM pg_catalog.pg_foreign_table ft "
15985 "JOIN pg_catalog.pg_foreign_server fs "
15986 "ON (fs.oid = ft.ftserver) "
15997 }
16004 }
16018 reltypename,
16019 qualrelname);
16021 /*
16022 * Attach to type, if reloftype; except in case of a binary upgrade,
16023 * we dump the table normally and attach it to the type afterward.
16024 */
16028 zeroAsOpaque));
16031 {
16032 /* Dump the attributes */
16035 {
16036 /*
16037 * Normally, dump if it's locally defined in this table, and
16038 * not dropped. But for binary upgrade, we'll dump all the
16039 * columns, and then fix up the dropped and nonlocal cases
16040 * below.
16041 */
16043 {
16047 /*
16048 * Default value --- suppress if to be printed separately.
16049 */
16053 /*
16054 * Not Null constraint --- suppress if inherited, except
16055 * if partition, or in binary-upgrade case where that
16056 * won't work.
16057 */
16062 /*
16063 * Skip column if fully defined by reloftype, except in
16064 * binary upgrade
16065 */
16071 /* Format properly if not first attr */
16074 else
16077 actual_atts++;
16079 /* Attribute name */
16083 {
16084 /*
16085 * ALTER TABLE DROP COLUMN clears
16086 * pg_attribute.atttypid, so we will not have gotten a
16087 * valid type name; insert INTEGER as a stopgap. We'll
16088 * clean things up later.
16089 */
16091 /* and skip to the next column */
16093 }
16095 /*
16096 * Attribute type; print it except when creating a typed
16097 * table ('OF type_name'), but in binary-upgrade mode,
16098 * print it in that case too.
16099 */
16101 {
16104 }
16107 {
16111 else
16114 }
16120 /* Add collation if not default for the type */
16122 {
16129 }
16130 }
16131 }
16133 /*
16134 * Add non-inherited CHECK constraints, if any.
16135 *
16136 * For partitions, we need to include check constraints even if
16137 * they're not defined locally, because the ALTER TABLE ATTACH
16138 * PARTITION that we'll emit later expects the constraint to be
16139 * there. (No need to fix conislocal: ATTACH PARTITION does that)
16140 */
16142 {
16151 else
16158 actual_atts++;
16159 }
16164 {
16165 /*
16166 * No attributes? we must have a parenthesized attribute list,
16167 * even though empty, when not using the OF TYPE syntax.
16168 */
16170 }
16172 /*
16173 * Emit the INHERITS clause (not for partitions), except in
16174 * binary-upgrade mode.
16175 */
16178 {
16181 {
16187 }
16189 }
16196 }
16200 {
16205 {
16208 }
16210 {
16214 fout);
16215 }
16217 }
16219 /* Dump generic options if any */
16223 /*
16224 * For materialized views, create the AS clause just like a view. At
16225 * this point, we always mark the view as not populated.
16226 */
16228 {
16229 PQExpBuffer result;
16235 }
16236 else
16239 /* Materialized views can depend on extensions */
16245 qualrelname);
16247 /*
16248 * in binary upgrade mode, update the catalog with any missing values
16249 * that might be present.
16250 */
16252 {
16254 {
16256 {
16266 }
16267 }
16268 }
16270 /*
16271 * To create binary-compatible heap files, we have to ensure the same
16272 * physical column order, including dropped columns, as in the
16273 * original. Therefore, we create dropped columns above and drop them
16274 * here, also updating their attlen/attalign values so that the
16275 * dropped column can be skipped properly. (We do not bother with
16276 * restoring the original attbyval setting.) Also, inheritance
16277 * relationships are set up by doing ALTER TABLE INHERIT rather than
16278 * using an INHERITS clause --- the latter would possibly mess up the
16279 * column order. That also means we have to take care about setting
16280 * attislocal correctly, plus fix up any inherited CHECK constraints.
16281 * Analogously, we set up typed tables using ALTER TABLE / OF here.
16282 *
16283 * We process foreign and partitioned tables here, even though they
16284 * lack heap storage, because they can participate in inheritance
16285 * relationships and we want this stuff to be consistent across the
16286 * inheritance tree. We can exclude indexes, toast tables, sequences
16287 * and matviews, even though they have storage, because we don't
16288 * support altering or dropping columns in them, nor can they be part
16289 * of inheritance trees.
16290 */
16295 {
16297 {
16299 {
16302 "SET attlen = %d, "
16315 qualrelname);
16316 else
16318 qualrelname);
16321 }
16323 {
16332 }
16333 }
16335 /*
16336 * Add inherited CHECK constraints, if any.
16337 *
16338 * For partitions, they were already dumped, and conislocal
16339 * doesn't need fixing.
16340 */
16342 {
16350 qualrelname);
16361 }
16364 {
16367 {
16371 qualrelname,
16373 }
16374 }
16377 {
16380 qualrelname,
16382 zeroAsOpaque));
16383 }
16384 }
16386 /*
16387 * For partitioned tables, emit the ATTACH PARTITION clause. Note
16388 * that we always want to create partitions this way instead of using
16389 * CREATE TABLE .. PARTITION OF, mainly to preserve a possible column
16390 * layout discrepancy with the parent, but also to ensure it gets the
16391 * correct tablespace setting if it differs from the parent's.
16392 */
16394 {
16397 PQExpBuffer q2;
16399 /* With partitions there can only be one parent */
16406 /* Fetch the partition's partbound */
16408 "SELECT pg_get_expr(c.relpartbound, c.oid) "
16409 "FROM pg_class c "
16415 /* Perform ALTER TABLE on the parent */
16423 }
16425 /*
16426 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
16427 * relminmxid of all vacuumable relations. (While vacuum.c processes
16428 * TOAST tables semi-independently, here we see them only as children
16429 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
16430 * child toast table is handled below.)
16431 */
16435 {
16445 {
16446 /*
16447 * The toast table will have the same OID at restore, so we
16448 * can safely target it by OID.
16449 */
16450 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
16456 }
16457 }
16459 /*
16460 * In binary_upgrade mode, restore matviews' populated status by
16461 * poking pg_class directly. This is pretty ugly, but we can't use
16462 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
16463 * matview is not populated even though this matview is; in any case,
16464 * we want to transfer the matview's heap storage, not run REFRESH.
16465 */
16468 {
16475 }
16477 /*
16478 * Dump additional per-column properties that we can't handle in the
16479 * main CREATE TABLE command.
16480 */
16482 {
16483 /* None of this applies to dropped columns */
16487 /*
16488 * If we didn't dump the column definition explicitly above, and
16489 * it is NOT NULL and did not inherit that property from a parent,
16490 * we have to mark it separately.
16491 */
16494 {
16496 qualrelname);
16499 }
16501 /*
16502 * Dump per-column statistics information. We only issue an ALTER
16503 * TABLE statement if the attstattarget entry for this column is
16504 * non-negative (i.e. it's not the default value)
16505 */
16507 {
16509 qualrelname);
16514 }
16516 /*
16517 * Dump per-column storage information. The statement is only
16518 * dumped if the storage has been changed from the type's default.
16519 */
16521 {
16523 {
16538 }
16540 /*
16541 * Only dump the statement if it's a storage type we recognize
16542 */
16544 {
16546 qualrelname);
16550 storage);
16551 }
16552 }
16554 /*
16555 * Dump per-column attributes.
16556 */
16558 {
16560 qualrelname);
16565 }
16567 /*
16568 * Dump per-column fdw options.
16569 */
16572 {
16574 qualrelname);
16579 }
16580 }
16588 }
16590 /*
16591 * dump properties we only have ALTER TABLE syntax for
16592 */
16597 {
16599 {
16600 /* nothing to do, will be set when the index is dumped */
16601 }
16603 {
16605 qualrelname);
16606 }
16608 {
16610 qualrelname);
16611 }
16612 }
16616 qualrelname);
16624 {
16643 }
16645 /* Dump Table Comments */
16649 /* Dump Table Security Labels */
16653 /* Dump comments on inlined table constraints */
16655 {
16663 }
16669 }
16671 /*
16672 * dumpAttrDef --- dump an attribute's default-value declaration
16673 */
16674 static void
16676 {
16680 PQExpBuffer q;
16681 PQExpBuffer delq;
16685 /* Skip if table definition not to be dumped */
16689 /* Skip if not "separate"; it was dumped in the table's definition */
16699 qualrelname);
16705 qualrelname);
16725 }
16727 /*
16728 * getAttrName: extract the correct name for an attribute
16729 *
16730 * The array tblInfo->attnames[] only provides names of user attributes;
16731 * if a system attribute number is supplied, we have to fake it.
16732 * We also do a little bit of bounds checking for safety's sake.
16733 */
16736 {
16740 {
16753 }
16757 }
16759 /*
16760 * dumpIndex
16761 * write out to fout a user-defined index
16762 */
16763 static void
16765 {
16769 PQExpBuffer q;
16770 PQExpBuffer delq;
16783 /*
16784 * If there's an associated constraint, don't dump the index per se, but
16785 * do dump any comment for it. (This is safe because dependency ordering
16786 * will have ensured the constraint is emitted first.) Note that the
16787 * emitted comment has to be shown as depending on the constraint, not the
16788 * index, in such cases.
16789 */
16791 {
16803 /* Plain secondary index */
16806 /*
16807 * Append ALTER TABLE commands as needed to set properties that we
16808 * only have ALTER TABLE syntax for. Keep this in sync with the
16809 * similar code in dumpConstraint!
16810 */
16812 /* If the index is clustered, we need to record that. */
16814 {
16817 /* index name is not qualified in this syntax */
16819 qindxname);
16820 }
16822 /*
16823 * If the index has any statistics on some of its columns, generate
16824 * the associated ALTER INDEX queries.
16825 */
16829 {
16833 {
16836 /*
16837 * Note that this is a column number, so no quotes should be
16838 * used.
16839 */
16844 }
16845 }
16847 /* Indexes can depend on extensions */
16852 /* If the index defines identity, we need to record that. */
16854 {
16857 /* index name is not qualified in this syntax */
16859 qindxname);
16860 }
16879 }
16881 /* Dump Index Comments */
16894 }
16896 /*
16897 * dumpIndexAttach
16898 * write out to fout a partitioned-index attachment clause
16899 */
16900 static void
16902 {
16907 {
16915 /*
16916 * There is no point in creating a drop query as the drop is done by
16917 * index drop. (If you think to change this, see also
16918 * _printTocEntry().) Although this object doesn't really have
16919 * ownership as such, set the owner field anyway to ensure that the
16920 * command is run by the correct role at restore time.
16921 */
16931 }
16932 }
16934 /*
16935 * dumpStatisticsExt
16936 * write out to fout an extended statistics object
16937 */
16938 static void
16940 {
16942 PQExpBuffer q;
16943 PQExpBuffer delq;
16944 PQExpBuffer query;
16949 /* Skip if not to be dumped */
16967 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
16984 /* Dump Statistics Comments */
16997 }
16999 /*
17000 * dumpConstraint
17001 * write out to fout a user-defined constraint
17002 */
17003 static void
17005 {
17008 PQExpBuffer q;
17009 PQExpBuffer delq;
17012 /* Skip if not to be dumped */
17022 {
17023 /* Index-related constraint */
17043 {
17044 /* pg_get_constraintdef should have provided everything */
17046 }
17047 else
17048 {
17052 {
17063 }
17069 {
17080 }
17085 {
17089 }
17092 {
17096 }
17099 }
17101 /*
17102 * Append ALTER TABLE commands as needed to set properties that we
17103 * only have ALTER TABLE syntax for. Keep this in sync with the
17104 * similar code in dumpIndex!
17105 */
17107 /* If the index is clustered, we need to record that. */
17109 {
17112 /* index name is not qualified in this syntax */
17115 }
17117 /* If the index defines identity, we need to record that. */
17119 {
17122 /* index name is not qualified in this syntax */
17125 }
17127 /* Indexes can depend on extensions */
17149 }
17151 {
17154 /*
17155 * Foreign keys on partitioned tables are always declared as
17156 * inheriting to partitions; for all other cases, emit them as
17157 * applying ONLY directly to the named table, because that's how they
17158 * work for regular inherited tables.
17159 */
17162 /*
17163 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
17164 * current table data is not processed
17165 */
17188 }
17190 {
17191 /* CHECK constraint on a table */
17193 /* Ignore if not to be dumped separately, or if it was inherited */
17195 {
17196 /* not ONLY since we want it to propagate to children */
17219 }
17220 }
17222 {
17223 /* CHECK constraint on a domain */
17226 /* Ignore if not to be dumped separately */
17228 {
17251 }
17252 }
17253 else
17254 {
17257 }
17259 /* Dump Constraint Comments --- only works for table constraints */
17267 }
17269 /*
17270 * dumpTableConstraintComment --- dump a constraint's comment if any
17271 *
17272 * This is split out because we need the function in two different places
17273 * depending on whether the constraint is dumped as part of CREATE TABLE
17274 * or as a separate ALTER command.
17275 */
17276 static void
17278 {
17297 }
17299 /*
17300 * findLastBuiltinOid_V71 -
17301 *
17302 * find the last built in oid
17303 *
17304 * For 7.1 through 8.0, we do this by retrieving datlastsysoid from the
17305 * pg_database entry for the current database. (Note: current_database()
17306 * requires 7.3; pg_dump requires 8.0 now.)
17307 */
17308 static Oid
17310 {
17312 Oid last_oid;
17320 }
17322 /*
17323 * dumpSequence
17324 * write the declaration (not data) of one user-defined sequence
17325 */
17326 static void
17328 {
17339 int64 default_minv,
17340 default_maxv;
17350 {
17352 "SELECT format_type(seqtypid, NULL), "
17353 "seqstart, seqincrement, "
17354 "seqmax, seqmin, "
17355 "seqcache, seqcycle "
17356 "FROM pg_catalog.pg_sequence "
17359 }
17361 {
17362 /*
17363 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
17364 *
17365 * Note: it might seem that 'bigint' potentially needs to be
17366 * schema-qualified, but actually that's a keyword.
17367 */
17369 "SELECT 'bigint' AS sequence_type, "
17370 "start_value, increment_by, max_value, min_value, "
17373 }
17374 else
17375 {
17377 "SELECT 'bigint' AS sequence_type, "
17378 "0 AS start_value, increment_by, max_value, min_value, "
17381 }
17386 {
17392 }
17402 /* Calculate default limits for a sequence of this type */
17405 {
17408 }
17410 {
17413 }
17415 {
17418 }
17419 else
17420 {
17423 }
17425 /*
17426 * 64-bit strtol() isn't very portable, so convert the limits to strings
17427 * and compare that way.
17428 */
17432 /* Don't print minv/maxv if they match the respective default limit */
17438 /*
17439 * Identity sequences are not to be dropped separately.
17440 */
17442 {
17445 }
17450 {
17455 }
17458 {
17473 }
17474 else
17475 {
17482 }
17491 else
17496 else
17505 else
17508 /* binary_upgrade: no need to clear TOAST table oid */
17525 /*
17526 * If the sequence is owned by a table column, emit the ALTER for it as a
17527 * separate TOC entry immediately following the sequence's own entry. It's
17528 * OK to do this rather than using full sorting logic, because the
17529 * dependency that tells us it's owned will have forced the table to be
17530 * created first. We can't just include the ALTER in the TOC entry
17531 * because it will fail if we haven't reassigned the sequence owner to
17532 * match the table's owner.
17533 *
17534 * We need not schema-qualify the table reference because both sequence
17535 * and table must be in the same schema.
17536 */
17538 {
17546 {
17565 }
17566 }
17568 /* Dump Sequence Comments and Security Labels */
17584 }
17586 /*
17587 * dumpSequenceData
17588 * write the data of one user-defined sequence
17589 */
17590 static void
17592 {
17606 {
17612 }
17637 }
17639 /*
17640 * dumpTrigger
17641 * write the declaration of one user-defined table trigger
17642 */
17643 static void
17645 {
17648 PQExpBuffer query;
17649 PQExpBuffer delqry;
17650 PQExpBuffer trigprefix;
17651 PQExpBuffer trigidentity;
17659 /*
17660 * we needn't check dobj.dump because TriggerInfo wouldn't have been
17661 * created in the first place for non-dumpable triggers
17662 */
17679 {
17681 }
17682 else
17683 {
17685 {
17688 }
17689 else
17690 {
17693 }
17696 /* Trigger type */
17703 else
17704 {
17707 }
17711 {
17713 findx++;
17714 }
17716 {
17719 else
17721 findx++;
17722 }
17724 {
17727 else
17729 findx++;
17730 }
17732 {
17735 else
17737 findx++;
17738 }
17743 {
17745 {
17746 /* regclass output is already quoted */
17749 }
17755 else
17757 }
17761 else
17764 /* regproc output is already sufficiently quoted */
17772 {
17773 /* find the embedded null that terminates this trigger argument */
17777 {
17778 /* hm, not found before end of bytea value... */
17784 }
17790 }
17793 }
17795 /* Triggers can depend on extensions */
17801 {
17802 /*
17803 * Triggers marked internal only appear here because their 'tgenabled'
17804 * flag differs from its parent's. The trigger is created already, so
17805 * remove the CREATE and replace it with an ALTER. (Clear out the
17806 * DROP query too, so that pg_dump --create does not cause errors.)
17807 */
17814 {
17829 }
17832 }
17834 {
17838 {
17852 }
17855 }
17883 }
17885 /*
17886 * dumpEventTrigger
17887 * write the declaration of one user-defined event trigger
17888 */
17889 static void
17891 {
17893 PQExpBuffer query;
17894 PQExpBuffer delqry;
17897 /* Skip if not to be dumped */
17912 {
17916 }
17923 {
17925 qevtname);
17927 {
17940 }
17942 }
17945 qevtname);
17968 }
17970 /*
17971 * dumpRule
17972 * Dump a rule
17973 */
17974 static void
17976 {
17980 PQExpBuffer query;
17981 PQExpBuffer cmd;
17982 PQExpBuffer delcmd;
17983 PQExpBuffer ruleprefix;
17988 /* Skip if not to be dumped */
17992 /*
17993 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
17994 * we do not want to dump it as a separate object.
17995 */
17999 /*
18000 * If it's an ON SELECT rule, we want to print it as a view definition,
18001 * instead of a rule.
18002 */
18013 {
18014 PQExpBuffer result;
18016 /*
18017 * We need OR REPLACE here because we'll be replacing a dummy view.
18018 * Otherwise this should look largely like the regular view dump code.
18019 */
18023 {
18027 }
18035 }
18036 else
18037 {
18038 /* In the rule case, just print pg_get_ruledef's result verbatim */
18046 {
18047 pg_log_error("query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned",
18050 }
18055 }
18057 /*
18058 * Add the command to alter the rules replication firing semantics if it
18059 * differs from the default.
18060 */
18062 {
18065 {
18078 }
18079 }
18082 {
18083 /*
18084 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
18085 * REPLACE VIEW to replace the rule with something with minimal
18086 * dependencies.
18087 */
18088 PQExpBuffer result;
18095 }
18096 else
18097 {
18102 }
18119 /* Dump rule comments */
18132 }
18134 /*
18135 * getExtensionMembership --- obtain extension membership data
18136 *
18137 * We need to identify objects that are extension members as soon as they're
18138 * loaded, so that we can correctly determine whether they need to be dumped.
18139 * Generally speaking, extension member objects will get marked as *not* to
18140 * be dumped, as they will be recreated by the single CREATE EXTENSION
18141 * command. However, in binary upgrade mode we still need to dump the members
18142 * individually.
18143 */
18144 void
18147 {
18148 PQExpBuffer query;
18151 nextmembers,
18152 i;
18154 i_objid,
18155 i_refobjid;
18159 /* Nothing to do if no extensions */
18165 /* refclassid constraint is redundant but may speed the search */
18167 "classid, objid, refobjid "
18168 "FROM pg_depend "
18169 "WHERE refclassid = 'pg_extension'::regclass "
18170 "AND deptype = 'e' "
18184 /*
18185 * Accumulate data into extmembers[].
18186 *
18187 * Since we ordered the SELECT by referenced ID, we can expect that
18188 * multiple entries for the same extension will appear together; this
18189 * saves on searches.
18190 */
18194 {
18195 CatalogId objId;
18196 Oid extId;
18207 {
18208 /* shouldn't happen */
18211 }
18215 nextmembers++;
18216 }
18220 /* Remember the data for use later */
18224 }
18226 /*
18227 * processExtensionTables --- deal with extension configuration tables
18228 *
18229 * There are two parts to this process:
18230 *
18231 * 1. Identify and create dump records for extension configuration tables.
18232 *
18233 * Extensions can mark tables as "configuration", which means that the user
18234 * is able and expected to modify those tables after the extension has been
18235 * loaded. For these tables, we dump out only the data- the structure is
18236 * expected to be handled at CREATE EXTENSION time, including any indexes or
18237 * foreign keys, which brings us to-
18238 *
18239 * 2. Record FK dependencies between configuration tables.
18240 *
18241 * Due to the FKs being created at CREATE EXTENSION time and therefore before
18242 * the data is loaded, we have to work out what the best order for reloading
18243 * the data is, to avoid FK violations when the tables are restored. This is
18244 * not perfect- we can't handle circular dependencies and if any exist they
18245 * will cause an invalid dump to be produced (though at least all of the data
18246 * is included for a user to manually restore). This is currently documented
18247 * but perhaps we can provide a better solution in the future.
18248 */
18249 void
18252 {
18254 PQExpBuffer query;
18257 i;
18259 i_confrelid;
18261 /* Nothing to do if no extensions */
18265 /*
18266 * Identify extension configuration tables and create TableDataInfo
18267 * objects for them, ensuring their data will be dumped even though the
18268 * tables themselves won't be.
18269 *
18270 * Note that we create TableDataInfo objects even in schemaOnly mode, ie,
18271 * user data in a configuration table is treated like schema data. This
18272 * seems appropriate since system data in a config table would get
18273 * reloaded by CREATE EXTENSION.
18274 */
18276 {
18288 {
18292 {
18302 /*
18303 * Tables of not-to-be-dumped extensions shouldn't be dumped
18304 * unless the table or its schema is explicitly included
18305 */
18307 {
18308 /* check table explicitly requested */
18311 configtbloid))
18314 /* check table's schema explicitly requested */
18316 DUMP_COMPONENT_DATA)
18318 }
18320 /* check table excluded by an exclusion switch */
18323 configtbloid))
18326 /* check schema excluded by an exclusion switch */
18332 {
18335 {
18338 }
18339 }
18340 }
18341 }
18346 }
18348 /*
18349 * Now that all the TableInfoData objects have been created for all the
18350 * extensions, check their FK dependencies and register them to try and
18351 * dump the data out in an order that they can be restored in.
18352 *
18353 * Note that this is not a problem for user tables as their FKs are
18354 * recreated after the data has been loaded.
18355 */
18360 "SELECT conrelid, confrelid "
18361 "FROM pg_constraint "
18362 "JOIN pg_depend ON (objid = confrelid) "
18363 "WHERE contype = 'f' "
18364 "AND refclassid = 'pg_extension'::regclass "
18373 /* Now get the dependencies and register them */
18375 {
18376 Oid conrelid,
18377 confrelid;
18392 /*
18393 * Make referencing TABLE_DATA object depend on the referenced table's
18394 * TABLE_DATA object.
18395 */
18398 }
18401 }
18403 /*
18404 * getDependencies --- obtain available dependency data
18405 */
18406 static void
18408 {
18409 PQExpBuffer query;
18412 i;
18414 i_objid,
18415 i_refclassid,
18416 i_refobjid,
18417 i_deptype;
18425 /*
18426 * Messy query to collect the dependency data we need. Note that we
18427 * ignore the sub-object column, so that dependencies of or on a column
18428 * look the same as dependencies of or on a whole table.
18429 *
18430 * PIN dependencies aren't interesting, and EXTENSION dependencies were
18431 * already processed by getExtensionMembership.
18432 */
18434 "classid, objid, refclassid, refobjid, deptype "
18435 "FROM pg_depend "
18438 /*
18439 * Since we don't treat pg_amop entries as separate DumpableObjects, we
18440 * have to translate their dependencies into dependencies of their parent
18441 * opfamily. Ignore internal dependencies though, as those will point to
18442 * their parent opclass, which we needn't consider here (and if we did,
18443 * it'd just result in circular dependencies). Also, "loose" opfamily
18444 * entries will have dependencies on their parent opfamily, which we
18445 * should drop since they'd likewise become useless self-dependencies.
18446 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
18447 *
18448 * Skip this for pre-8.3 source servers: pg_opfamily doesn't exist there,
18449 * and the (known) cases where it would matter to have these dependencies
18450 * can't arise anyway.
18451 */
18453 {
18455 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
18456 "FROM pg_depend d, pg_amop o "
18457 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18458 "classid = 'pg_amop'::regclass AND objid = o.oid "
18461 /* Likewise for pg_amproc entries */
18463 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
18464 "FROM pg_depend d, pg_amproc p "
18465 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
18466 "classid = 'pg_amproc'::regclass AND objid = p.oid "
18468 }
18470 /* Sort the output for efficiency below */
18483 /*
18484 * Since we ordered the SELECT by referencing ID, we can expect that
18485 * multiple entries for the same object will appear together; this saves
18486 * on searches.
18487 */
18491 {
18492 CatalogId objId;
18493 CatalogId refobjId;
18507 /*
18508 * Failure to find objects mentioned in pg_depend is not unexpected,
18509 * since for example we don't collect info about TOAST tables.
18510 */
18512 {
18513 #ifdef NOT_USED
18516 #endif
18518 }
18523 {
18524 #ifdef NOT_USED
18527 #endif
18529 }
18531 /*
18532 * For 'x' dependencies, mark the object for later; we still add the
18533 * normal dependency, for possible ordering purposes. Currently
18534 * pg_dump_sort.c knows to put extensions ahead of all object types
18535 * that could possibly depend on them, but this is safer.
18536 */
18540 /*
18541 * Ordinarily, table rowtypes have implicit dependencies on their
18542 * tables. However, for a composite type the implicit dependency goes
18543 * the other way in pg_depend; which is the right thing for DROP but
18544 * it doesn't produce the dependency ordering we need. So in that one
18545 * case, we reverse the direction of the dependency.
18546 */
18551 else
18552 /* normal case */
18554 }
18559 }
18562 /*
18563 * createBoundaryObjects - create dummy DumpableObjects to represent
18564 * dump section boundaries.
18565 */
18568 {
18584 }
18586 /*
18587 * addBoundaryDependencies - add dependencies as needed to enforce the dump
18588 * section boundaries.
18589 */
18590 static void
18593 {
18599 {
18602 /*
18603 * The classification of object types here must match the SECTION_xxx
18604 * values assigned during subsequent ArchiveEntry calls!
18605 */
18607 {
18633 /* Pre-data objects: must come before the pre-data boundary */
18639 /* Data objects: must come between the boundaries */
18654 /* Post-data objects: must come after the post-data boundary */
18658 /* Rules are post-data, but only if dumped separately */
18664 /* Constraints are post-data, but only if dumped separately */
18669 /* nothing to do */
18672 /* must come after the pre-data boundary */
18675 }
18676 }
18677 }
18680 /*
18681 * BuildArchiveDependencies - create dependency data for archive TOC entries
18682 *
18683 * The raw dependency data obtained by getDependencies() is not terribly
18684 * useful in an archive dump, because in many cases there are dependency
18685 * chains linking through objects that don't appear explicitly in the dump.
18686 * For example, a view will depend on its _RETURN rule while the _RETURN rule
18687 * will depend on other objects --- but the rule will not appear as a separate
18688 * object in the dump. We need to adjust the view's dependencies to include
18689 * whatever the rule depends on that is included in the dump.
18690 *
18691 * Just to make things more complicated, there are also "special" dependencies
18692 * such as the dependency of a TABLE DATA item on its TABLE, which we must
18693 * not rearrange because pg_restore knows that TABLE DATA only depends on
18694 * its table. In these cases we must leave the dependencies strictly as-is
18695 * even if they refer to not-to-be-dumped objects.
18696 *
18697 * To handle this, the convention is that "special" dependencies are created
18698 * during ArchiveEntry calls, and an archive TOC item that has any such
18699 * entries will not be touched here. Otherwise, we recursively search the
18700 * DumpableObject data structures to build the correct dependencies for each
18701 * archive TOC item.
18702 */
18703 static void
18705 {
18709 /* Scan all TOC entries in the archive */
18711 {
18717 /* No need to process entries that will not be dumped */
18720 /* Ignore entries that already have "special" dependencies */
18723 /* Otherwise, look up the item's original DumpableObject, if any */
18727 /* No work if it has no dependencies */
18730 /* Set up work array */
18734 /* Recursively find all dumpable dependencies */
18737 /* And save 'em ... */
18739 {
18744 }
18745 else
18747 }
18748 }
18750 /* Recursive search subroutine for BuildArchiveDependencies */
18751 static void
18754 {
18757 /*
18758 * Ignore section boundary objects: if we search through them, we'll
18759 * report lots of bogus dependencies.
18760 */
18766 {
18770 {
18771 /* Object will be dumped, so just reference it as a dependency */
18773 {
18777 }
18780 }
18781 else
18782 {
18783 /*
18784 * Object will not be dumped, so recursively consider its deps. We
18785 * rely on the assumption that sortDumpableObjects already broke
18786 * any dependency loops, else we might recurse infinitely.
18787 */
18793 }
18794 }
18795 }
18798 /*
18799 * getFormattedTypeName - retrieve a nicely-formatted type name for the
18800 * given type OID.
18801 *
18802 * This does not guarantee to schema-qualify the output, so it should not
18803 * be used to create the target object name for CREATE or ALTER commands.
18804 *
18805 * Note that the result is cached and must not be freed by the caller.
18806 */
18809 {
18812 PQExpBuffer query;
18816 {
18825 }
18827 /* see if we have the result cached in the type's TypeInfo record */
18834 oid);
18838 /* result of format_type is already quoted */
18844 /*
18845 * Cache the result for re-use in later requests, if possible. If we
18846 * don't have a TypeInfo for the type, the string will be leaked once the
18847 * caller is done with it ... but that case really should not happen, so
18848 * leaking if it does seems acceptable.
18849 */
18854 }
18856 /*
18857 * Return a column list clause for the given relation.
18858 *
18859 * Special case: if there are no undropped columns in the relation, return
18860 * "", not an invalid "()" column list.
18861 */
18864 {
18875 {
18884 }
18891 }
18893 /*
18894 * Check if a reloptions array is nonempty.
18895 */
18896 static bool
18898 {
18899 /* Don't want to print it if it's just "{}" */
18901 }
18903 /*
18904 * Format a reloptions array and append it to the given buffer.
18905 *
18906 * "prefix" is prepended to the option names; typically it's "" or "toast.".
18907 */
18908 static void
18911 {
18918 }