Loading...
Searching...
No Matches
pg_dump.c File Reference
#include "postgres_fe.h"#include <unistd.h>#include <ctype.h>#include <limits.h>#include "access/attnum.h"#include "access/sysattr.h"#include "access/transam.h"#include "catalog/pg_aggregate_d.h"#include "catalog/pg_am_d.h"#include "catalog/pg_attribute_d.h"#include "catalog/pg_authid_d.h"#include "catalog/pg_cast_d.h"#include "catalog/pg_class_d.h"#include "catalog/pg_constraint_d.h"#include "catalog/pg_default_acl_d.h"#include "catalog/pg_largeobject_d.h"#include "catalog/pg_largeobject_metadata_d.h"#include "catalog/pg_proc_d.h"#include "catalog/pg_publication_d.h"#include "catalog/pg_shdepend_d.h"#include "catalog/pg_subscription_d.h"#include "catalog/pg_type_d.h"#include "common/connect.h"#include "common/int.h"#include "common/relpath.h"#include "common/shortest_dec.h"#include "compress_io.h"#include "dumputils.h"#include "fe_utils/option_utils.h"#include "fe_utils/string_utils.h"#include "filter.h"#include "getopt_long.h"#include "libpq/libpq-fs.h"#include "parallel.h"#include "pg_backup_db.h"#include "pg_backup_utils.h"#include "pg_dump.h"#include "statistics/statistics_format.h"#include "storage/block.h"
Include dependency graph for pg_dump.c:
Go to the source code of this file.
Data Structures | |
| struct | RoleNameItem |
| struct | CommentItem |
| struct | SecLabelItem |
| struct | BinaryUpgradeClassOidItem |
| struct | SequenceItem |
Macros | |
| #define | MAX_ATTR_STATS_RELS 64 |
| #define | DUMP_DEFAULT_ROWS_PER_INSERT 1 |
| #define | MAX_BLOBS_PER_ARCHIVE_ENTRY 1000 |
| #define | fmtQualifiedDumpable(obj) |
Typedefs | |
| typedef enum SeqType | SeqType |
| typedef enum OidOptions | OidOptions |
Enumerations | |
| enum | SeqType { SEQTYPE_SMALLINT , SEQTYPE_INTEGER , SEQTYPE_BIGINT } |
| enum | OidOptions { zeroIsError = 1 , zeroAsStar = 2 , zeroAsNone = 4 } |
Macro Definition Documentation
◆ DUMP_DEFAULT_ROWS_PER_INSERT
◆ fmtQualifiedDumpable
| #define fmtQualifiedDumpable | ( | obj | ) |
Value:
fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
(obj)->dobj.name)
const char * fmtQualifiedId(const char *schema, const char *id)
Definition string_utils.c:296
Definition at line 242 of file pg_dump.c.
424{
428 TableInfo *tblinfo;
435 RestoreOptions *ropt;
441 int numWorkers = 1;
445 pg_compress_specification compression_spec = {0};
458
460
494
495 /*
496 * the following options don't have an equivalent short option letter
497 */
543
545 };
546
547 pg_logging_init(argv[0]);
550
551 /*
552 * Initialize what we need for parallel execution, especially for thread
553 * support on Windows.
554 */
555 init_parallel_dump_utils();
556
558
559 if (argc > 1)
560 {
562 {
564 exit_nicely(0);
565 }
567 {
569 exit_nicely(0);
570 }
571 }
572
573 InitDumpOptions(&dopt);
574
577 {
579 {
580 case 'a': /* Dump data only */
582 break;
583
584 case 'b': /* Dump LOs */
586 break;
587
588 case 'B': /* Don't dump LOs */
590 break;
591
592 case 'c': /* clean (i.e., drop) schema prior to create */
593 dopt.outputClean = 1;
594 break;
595
596 case 'C': /* Create DB */
597 dopt.outputCreateDB = 1;
598 break;
599
600 case 'd': /* database name */
602 break;
603
604 case 'e': /* include extension(s) */
607 break;
608
609 case 'E': /* Dump encoding */
611 break;
612
613 case 'f':
615 break;
616
617 case 'F':
619 break;
620
621 case 'h': /* server host */
623 break;
624
625 case 'j': /* number of dump jobs */
627 PG_MAX_JOBS,
628 &numWorkers))
629 exit_nicely(1);
630 break;
631
632 case 'n': /* include schema(s) */
635 break;
636
637 case 'N': /* exclude schema(s) */
639 break;
640
641 case 'O': /* Don't reconnect to match owner */
642 dopt.outputNoOwner = 1;
643 break;
644
645 case 'p': /* server port */
647 break;
648
649 case 'R':
650 /* no-op, still accepted for backwards compatibility */
651 break;
652
653 case 's': /* dump schema only */
655 break;
656
657 case 'S': /* Username for superuser in plain text output */
659 break;
660
661 case 't': /* include table(s) */
664 break;
665
666 case 'T': /* exclude table(s) */
668 break;
669
670 case 'U':
672 break;
673
674 case 'v': /* verbose */
677 break;
678
679 case 'w':
681 break;
682
683 case 'W':
685 break;
686
687 case 'x': /* skip ACL dump */
689 break;
690
691 case 'Z': /* Compression */
693 &compression_detail);
695 break;
696
697 case 0:
698 /* This covers the long options. */
699 break;
700
701 case 2: /* lock-wait-timeout */
703 break;
704
705 case 3: /* SET ROLE */
707 break;
708
709 case 4: /* exclude table(s) data */
711 break;
712
713 case 5: /* section */
715 break;
716
717 case 6: /* snapshot */
719 break;
720
721 case 7: /* no-sync */
723 break;
724
725 case 8:
728 &extra_float_digits))
729 exit_nicely(1);
730 break;
731
732 case 9: /* inserts */
733
734 /*
735 * dump_inserts also stores --rows-per-insert, careful not to
736 * overwrite that.
737 */
740 break;
741
742 case 10: /* rows per insert */
744 &dopt.dump_inserts))
745 exit_nicely(1);
746 break;
747
748 case 11: /* include foreign data */
750 optarg);
751 break;
752
753 case 12: /* include table(s) and their children */
755 optarg);
757 break;
758
759 case 13: /* exclude table(s) and their children */
761 optarg);
762 break;
763
764 case 14: /* exclude data of table(s) and children */
766 optarg);
767 break;
768
769 case 15:
771 exit_nicely(1);
772 break;
773
774 case 16: /* read object filters from file */
776 break;
777
778 case 17: /* exclude extension(s) */
780 optarg);
781 break;
782
783 case 18:
785 break;
786
787 case 19:
789 break;
790
791 case 20:
793 break;
794
795 case 21:
797 break;
798
799 case 22:
801 break;
802
803 case 25:
805 break;
806
807 default:
808 /* getopt_long already emitted a complaint */
810 exit_nicely(1);
811 }
812 }
813
814 /*
815 * Non-option argument specifies database name as long as it wasn't
816 * already specified with -d / --dbname
817 */
820
821 /* Complain if any arguments remain */
823 {
825 argv[optind]);
827 exit_nicely(1);
828 }
829
830 /* --column-inserts implies --inserts */
833
834 /* reject conflicting "-only" options */
837 "-s/--schema-only", "-a/--data-only");
840 "-s/--schema-only", "--statistics-only");
843 "-a/--data-only", "--statistics-only");
844
845 /* reject conflicting "-only" and "no-" options */
848 "-a/--data-only", "--no-data");
851 "-s/--schema-only", "--no-schema");
854 "--statistics-only", "--no-statistics");
855
856 /* reject conflicting "no-" options */
859 "--statistics", "--no-statistics");
860
861 /* reject conflicting "-only" options */
864 "-a/--data-only", "--statistics");
867 "-s/--schema-only", "--statistics");
868
871 "-s/--schema-only", "--include-foreign-data");
872
875 "--include-foreign-data");
876
879 "-c/--clean", "-a/--data-only");
880
883 "--if-exists", "-c/--clean");
884
885 /*
886 * Set derivative flags. Ambiguous or nonsensical combinations, e.g.
887 * "--schema-only --no-schema", will have already caused an error in one
888 * of the checks above.
889 */
896
897
898 /*
899 * --inserts are already implied above if --column-inserts or
900 * --rows-per-insert were specified.
901 */
904 "--on-conflict-do-nothing",
905 "--inserts", "--rows-per-insert", "--column-inserts");
906
907 /* Identify archive format to emit */
909
910 /* archiveFormat specific setup */
912 {
913 plainText = 1;
914
915 /*
916 * If you don't provide a restrict key, one will be appointed for you.
917 */
924 }
927 "--restrict-key", "--format=plain");
928
929 /*
930 * Custom and directory formats are compressed by default with gzip when
931 * available, not the others. If gzip is not available, no compression is
932 * done by default.
933 */
935 !user_compression_defined)
936 {
937#ifdef HAVE_LIBZ
939#else
941#endif
942 }
943
944 /*
945 * Compression options
946 */
948 &compression_algorithm))
951
953 &compression_spec);
957 error_detail);
958
962
963 /*
964 * Disable support for zstd workers for now - these are based on
965 * threading, and it's unclear how it interacts with parallel dumps on
966 * platforms where that relies on threads too (e.g. Windows).
967 */
970 "workers");
971
972 /*
973 * If emitting an archive format, we always want to emit a DATABASE item,
974 * in case --create is specified at pg_restore time.
975 */
977 dopt.outputCreateDB = 1;
978
979 /* Parallel backup only in the directory archive format so far */
982
983 /* Open the output file */
986
987 /* Make dump options accessible right away */
989
990 /* Register the cleanup hook */
992
993 /* Let the archiver know how noisy to be */
995
996
997 /*
998 * We allow the server to be back to 9.2, and up to any minor release of
999 * our own major version. (See also version check in pg_dumpall.c.)
1000 */
1001 fout->minRemoteVersion = 90200;
1003
1004 fout->numWorkers = numWorkers;
1005
1006 /*
1007 * Open the database using the Archiver, so it knows about it. Errors mean
1008 * death.
1009 */
1012
1013 /*
1014 * On hot standbys, never try to dump unlogged table data, since it will
1015 * just throw an error.
1016 */
1019
1020 /*
1021 * Find the last built-in OID, if needed (prior to 8.1)
1022 *
1023 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
1024 */
1026
1028
1029 /* Expand schema selection patterns into OID lists */
1031 {
1033 &schema_include_oids,
1034 strict_names);
1037 }
1039 &schema_exclude_oids,
1040 false);
1041 /* non-matching exclusion patterns aren't an error */
1042
1043 /* Expand table selection patterns into OID lists */
1045 &table_include_oids,
1048 &table_include_oids,
1054
1056 &table_exclude_oids,
1057 false, false);
1059 &table_exclude_oids,
1060 false, true);
1061
1063 &tabledata_exclude_oids,
1064 false, false);
1066 &tabledata_exclude_oids,
1067 false, true);
1068
1070 &foreign_servers_include_oids);
1071
1072 /* non-matching exclusion patterns aren't an error */
1073
1074 /* Expand extension selection patterns into OID lists */
1076 {
1078 &extension_include_oids,
1079 strict_names);
1082 }
1084 &extension_exclude_oids,
1085 false);
1086 /* non-matching exclusion patterns aren't an error */
1087
1088 /*
1089 * Dumping LOs is the default for dumps where an inclusion switch is not
1090 * used (an "include everything" dump). -B can be used to exclude LOs
1091 * from those dumps. -b can be used to include LOs even when an inclusion
1092 * switch is used.
1093 *
1094 * -s means "schema only" and LOs are data, not schema, so we never
1095 * include LOs when -s is used.
1096 */
1099
1100 /*
1101 * Collect role names so we can map object owner OIDs to names.
1102 */
1104
1105 /*
1106 * Now scan the database and create DumpableObject structs for all the
1107 * objects we intend to dump.
1108 */
1110
1112 {
1116 getTableDataFKConstraints();
1117 }
1118
1121
1122 /*
1123 * For binary upgrade mode, dump pg_largeobject_metadata and the
1124 * associated pg_shdepend rows. This is faster to restore than the
1125 * equivalent set of large object commands. We can only do this for
1126 * upgrades from v12 and newer; in older versions, pg_largeobject_metadata
1127 * was created WITH OIDS, so the OID column is hidden and won't be dumped.
1128 */
1130 {
1133
1136
1137 /*
1138 * Save pg_largeobject_metadata's dump ID for use as a dependency for
1139 * pg_shdepend and any large object comments/seclabels.
1140 */
1143
1144 /*
1145 * Only dump large object shdepend rows for this database.
1146 */
1148 "AND dbid = (SELECT oid FROM pg_database "
1149 " WHERE datname = current_database())";
1150
1151 /*
1152 * If upgrading from v16 or newer, only dump large objects with
1153 * comments/seclabels. For these upgrades, pg_upgrade can copy/link
1154 * pg_largeobject_metadata's files (which is usually faster) but we
1155 * still need to dump LOs with comments/seclabels here so that the
1156 * subsequent COMMENT and SECURITY LABEL commands work. pg_upgrade
1157 * can't copy/link the files from older versions because aclitem
1158 * (needed by pg_largeobject_metadata.lomacl) changed its storage
1159 * format in v16.
1160 */
1163 "(SELECT objoid FROM pg_description "
1165 "UNION SELECT objoid FROM pg_seclabel "
1167 }
1168
1169 /*
1170 * In binary-upgrade mode, we do not have to worry about the actual LO
1171 * data or the associated metadata that resides in the pg_largeobject and
1172 * pg_largeobject_metadata tables, respectively.
1173 *
1174 * However, we do need to collect LO information as there may be comments
1175 * or other information on LOs that we do need to dump out.
1176 */
1179
1180 /*
1181 * Collect dependency data to assist in ordering the objects.
1182 */
1184
1185 /*
1186 * Collect ACLs, comments, and security labels, if wanted.
1187 */
1194
1195 /* For binary upgrade mode, collect required pg_class information. */
1198
1199 /* Collect sequence information. */
1201
1202 /* Lastly, create dummy objects to represent the section boundaries */
1204
1205 /* Get pointers to all the known DumpableObjects */
1207
1208 /*
1209 * Add dummy dependencies to enforce the dump section ordering.
1210 */
1212
1213 /*
1214 * Sort the objects into a safe dump order (no forward references).
1215 *
1216 * We rely on dependency information to help us determine a safe order, so
1217 * the initial sort is mostly for cosmetic purposes: we sort by name to
1218 * ensure that logically identical schemas will dump identically.
1219 */
1221
1224
1225 /*
1226 * Create archive TOC entries for all the objects to be dumped, in a safe
1227 * order.
1228 */
1229
1230 /*
1231 * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
1232 */
1236
1237 /* The database items are always next, unless we don't want them at all */
1240
1241 /* Now the rearrangeable objects. */
1244
1245 /*
1246 * Set up options info to ensure we dump what we want.
1247 */
1248 ropt = NewRestoreOptions();
1250
1251 /* if you change this list, see dumpOptionsFromRestoreOptions */
1285
1286 ropt->compression_spec = compression_spec;
1287
1289
1291
1292 /* Mark which entries should be output */
1294
1295 /*
1296 * The archive's TOC entries are now marked as to which ones will actually
1297 * be output, so we can set up their dependency lists properly. This isn't
1298 * necessary for plain-text output, though.
1299 */
1302
1303 /*
1304 * And finally we can do the actual output.
1305 *
1306 * Note: for non-plain-text output formats, the output file is written
1307 * inside CloseArchive(). This is, um, bizarre; but not worth changing
1308 * right now.
1309 */
1312
1314
1315 exit_nicely(0);
1316}
1317
1318
1319static void
1321{
1322 printf(_("%s exports a PostgreSQL database as an SQL script or to other formats.\n\n"), progname);
1325
1329 " plain text (default))\n"));
1334 " compress as specified\n"));
1339
1353 " plain-text format\n"));
1364 " access to)\n"));
1367 " do NOT dump the specified table(s), including\n"
1368 " child and partition tables\n"));
1371 " do NOT dump data for the specified table(s),\n"
1372 " including child and partition tables\n"));
1375 " based on expressions in FILENAME\n"));
1378 " include data of foreign tables on foreign\n"
1379 " servers matching PATTERN\n"));
1405 " match at least one entity each\n"));
1407 " child and partition tables\n"));
1409 " use SET SESSION AUTHORIZATION commands instead of\n"
1410 " ALTER OWNER commands to set ownership\n"));
1411
1420
1422 "variable value is used.\n\n"));
1425}
1426
1427static void
1430{
1433
1435
1436 /*
1437 * Set the client encoding if requested.
1438 */
1440 {
1443 dumpencoding);
1444 }
1445
1446 /*
1447 * Force standard_conforming_strings on, just in case we are dumping from
1448 * an old server that has it disabled. Without this, literals in views,
1449 * expressions, etc, would be incorrect for modern servers.
1450 */
1452
1453 /*
1454 * And reflect that to AH->std_strings. You might think that we should
1455 * just delete that variable and the code that checks it, but that would
1456 * be problematic for pg_restore, which at least for now should still cope
1457 * with archives containing the other setting (cf. processStdStringsEntry
1458 * in pg_backup_archiver.c).
1459 */
1461
1462 /*
1463 * Get the active encoding, so we know how to escape strings.
1464 */
1467
1468 /*
1469 * Set the role if requested. In a parallel dump worker, we'll be passed
1470 * use_role == NULL, but AH->use_role is already set (if user specified it
1471 * originally) and we should use that.
1472 */
1474 use_role = AH->use_role;
1475
1476 /* Set the role if requested */
1477 if (use_role)
1478 {
1480
1483 destroyPQExpBuffer(query);
1484
1485 /* save it for possible later use by parallel workers */
1488 }
1489
1490 /* Set the datestyle to ISO to ensure the dump's portability */
1492
1493 /* Likewise, avoid using sql_standard intervalstyle */
1495
1496 /*
1497 * Use an explicitly specified extra_float_digits if it has been provided.
1498 * Otherwise, set extra_float_digits so that we can dump float data
1499 * exactly (given correctly implemented float I/O code, anyway).
1500 */
1502 {
1504
1506 extra_float_digits);
1508 destroyPQExpBuffer(q);
1509 }
1510 else
1512
1513 /*
1514 * Disable synchronized scanning, to prevent unpredictable changes in row
1515 * ordering across a dump and reload.
1516 */
1518
1519 /*
1520 * Disable timeouts if supported.
1521 */
1529
1530 /*
1531 * Quote all identifiers, if requested.
1532 */
1535
1536 /*
1537 * Adjust row-security mode, if supported.
1538 */
1540 {
1543 else
1545 }
1546
1547 /*
1548 * For security reasons, we restrict the expansion of non-system views and
1549 * access to foreign tables during the pg_dump process. This restriction
1550 * is adjusted when dumping foreign table data.
1551 */
1553
1554 /*
1555 * Initialize prepared-query state to "nothing prepared". We do this here
1556 * so that a parallel dump worker will have its own state.
1557 */
1559
1560 /*
1561 * Start transaction-snapshot mode transaction to dump consistent data.
1562 */
1564
1565 /*
1566 * To support the combination of serializable_deferrable with the jobs
1567 * option we use REPEATABLE READ for the worker connections that are
1568 * passed a snapshot. As long as the snapshot is acquired in a
1569 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1570 * REPEATABLE READ transaction provides the appropriate integrity
1571 * guarantees. This is a kluge, but safe for back-patching.
1572 */
1574 ExecuteSqlStatement(AH,
1575 "SET TRANSACTION ISOLATION LEVEL "
1576 "SERIALIZABLE, READ ONLY, DEFERRABLE");
1577 else
1578 ExecuteSqlStatement(AH,
1579 "SET TRANSACTION ISOLATION LEVEL "
1580 "REPEATABLE READ, READ ONLY");
1581
1582 /*
1583 * If user specified a snapshot to use, select that. In a parallel dump
1584 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1585 * is already set (if the server can handle it) and we should use that.
1586 */
1589
1591 {
1593
1597 destroyPQExpBuffer(query);
1598 }
1600 {
1604 }
1605}
1606
1607/* Set up connection for a parallel worker process */
1608static void
1610{
1611 /*
1612 * We want to re-select all the same values the leader connection is
1613 * using. We'll have inherited directly-usable values in
1614 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1615 * inherited encoding value back to a string to pass to setup_connection.
1616 */
1617 setup_connection(AH,
1619 NULL,
1620 NULL);
1621}
1622
1623static char *
1625{
1626 char *query = "SELECT pg_catalog.pg_export_snapshot()";
1627 char *result;
1628 PGresult *res;
1629
1632 PQclear(res);
1633
1634 return result;
1635}
1636
1639{
1641
1643
1645 {
1646 /* This is used by pg_dumpall, and is not documented */
1649 }
1666 else
1669}
1670
1671/*
1672 * Find the OIDs of all schemas matching the given list of patterns,
1673 * and append them to the given OID list.
1674 */
1675static void
1678 SimpleOidList *oids,
1680{
1681 PQExpBuffer query;
1682 PGresult *res;
1683 SimpleStringListCell *cell;
1685
1687 return; /* nothing to do */
1688
1689 query = createPQExpBuffer();
1690
1691 /*
1692 * The loop below runs multiple SELECTs might sometimes result in
1693 * duplicate entries in the OID list, but we don't care.
1694 */
1695
1697 {
1700
1701 appendPQExpBufferStr(query,
1702 "SELECT oid FROM pg_catalog.pg_namespace n\n");
1706 &dotcnt);
1709 cell->val);
1713
1717
1719 {
1721 }
1722
1723 PQclear(res);
1724 resetPQExpBuffer(query);
1725 }
1726
1727 destroyPQExpBuffer(query);
1728}
1729
1730/*
1731 * Find the OIDs of all extensions matching the given list of patterns,
1732 * and append them to the given OID list.
1733 */
1734static void
1737 SimpleOidList *oids,
1739{
1740 PQExpBuffer query;
1741 PGresult *res;
1742 SimpleStringListCell *cell;
1744
1746 return; /* nothing to do */
1747
1748 query = createPQExpBuffer();
1749
1750 /*
1751 * The loop below runs multiple SELECTs might sometimes result in
1752 * duplicate entries in the OID list, but we don't care.
1753 */
1755 {
1757
1758 appendPQExpBufferStr(query,
1759 "SELECT oid FROM pg_catalog.pg_extension e\n");
1762 &dotcnt);
1765 cell->val);
1766
1770
1772 {
1774 }
1775
1776 PQclear(res);
1777 resetPQExpBuffer(query);
1778 }
1779
1780 destroyPQExpBuffer(query);
1781}
1782
1783/*
1784 * Find the OIDs of all foreign servers matching the given list of patterns,
1785 * and append them to the given OID list.
1786 */
1787static void
1790 SimpleOidList *oids)
1791{
1792 PQExpBuffer query;
1793 PGresult *res;
1794 SimpleStringListCell *cell;
1796
1798 return; /* nothing to do */
1799
1800 query = createPQExpBuffer();
1801
1802 /*
1803 * The loop below runs multiple SELECTs might sometimes result in
1804 * duplicate entries in the OID list, but we don't care.
1805 */
1806
1808 {
1810
1811 appendPQExpBufferStr(query,
1812 "SELECT oid FROM pg_catalog.pg_foreign_server s\n");
1815 &dotcnt);
1818 cell->val);
1819
1823
1826
1827 PQclear(res);
1828 resetPQExpBuffer(query);
1829 }
1830
1831 destroyPQExpBuffer(query);
1832}
1833
1834/*
1835 * Find the OIDs of all tables matching the given list of patterns,
1836 * and append them to the given OID list. See also expand_dbname_patterns()
1837 * in pg_dumpall.c
1838 */
1839static void
1843{
1844 PQExpBuffer query;
1845 PGresult *res;
1846 SimpleStringListCell *cell;
1848
1850 return; /* nothing to do */
1851
1852 query = createPQExpBuffer();
1853
1854 /*
1855 * this might sometimes result in duplicate entries in the OID list, but
1856 * we don't care.
1857 */
1858
1860 {
1863
1864 /*
1865 * Query must remain ABSOLUTELY devoid of unqualified names. This
1866 * would be unnecessary given a pg_table_is_visible() variant taking a
1867 * search_path argument.
1868 *
1869 * For with_child_tables, we start with the basic query's results and
1870 * recursively search the inheritance tree to add child tables.
1871 */
1873 {
1875 }
1876
1877 appendPQExpBuffer(query,
1878 "SELECT c.oid"
1879 "\nFROM pg_catalog.pg_class c"
1880 "\n LEFT JOIN pg_catalog.pg_namespace n"
1881 "\n ON n.oid OPERATOR(pg_catalog.=) c.relnamespace"
1882 "\nWHERE c.relkind OPERATOR(pg_catalog.=) ANY"
1883 "\n (array['%c', '%c', '%c', '%c', '%c', '%c'])\n",
1886 RELKIND_PARTITIONED_TABLE);
1891 &dotcnt);
1894 cell->val);
1898
1900 {
1902 "\nSELECT i.inhrelid"
1903 "\nFROM partition_tree p"
1904 "\n JOIN pg_catalog.pg_inherits i"
1905 "\n ON p.relid OPERATOR(pg_catalog.=) i.inhparent"
1906 "\n)"
1907 "\nSELECT relid FROM partition_tree");
1908 }
1909
1913 ALWAYS_SECURE_SEARCH_PATH_SQL));
1916
1918 {
1920 }
1921
1922 PQclear(res);
1923 resetPQExpBuffer(query);
1924 }
1925
1926 destroyPQExpBuffer(query);
1927}
1928
1929/*
1930 * Verifies that the connected database name matches the given database name,
1931 * and if not, dies with an error about the given pattern.
1932 *
1933 * The 'dbname' argument should be a literal name parsed from 'pattern'.
1934 */
1935static void
1937{
1938 const char *db;
1939
1943
1946 pattern);
1947}
1948
1949/*
1950 * checkExtensionMembership
1951 * Determine whether object is an extension member, and if so,
1952 * record an appropriate dependency and set the object's dump flag.
1953 *
1954 * It's important to call this for each object that could be an extension
1955 * member. Generally, we integrate this with determining the object's
1956 * to-be-dumped-ness, since extension membership overrides other rules for that.
1957 *
1958 * Returns true if object is an extension member, else false.
1959 */
1960static bool
1962{
1964
1966 return false;
1967
1969
1970 /* Record dependency so that getDependencies needn't deal with that */
1972
1973 /*
1974 * In 9.6 and above, mark the member object to have any non-initial ACLs
1975 * dumped. (Any initial ACLs will be removed later, using data from
1976 * pg_init_privs, so that we'll dump only the delta from the extension's
1977 * initial setup.)
1978 *
1979 * Prior to 9.6, we do not include any extension member components.
1980 *
1981 * In binary upgrades, we still dump all components of the members
1982 * individually, since the idea is to exactly reproduce the database
1983 * contents rather than replace the extension contents with something
1984 * different.
1985 *
1986 * Note: it might be interesting someday to implement storage and delta
1987 * dumping of extension members' RLS policies and/or security labels.
1988 * However there is a pitfall for RLS policies: trying to dump them
1989 * requires getting a lock on their tables, and the calling user might not
1990 * have privileges for that. We need no lock to examine a table's ACLs,
1991 * so the current feature doesn't have a problem of that sort.
1992 */
1995 else
1996 {
1999 else
2001 }
2002
2003 return true;
2004}
2005
2006/*
2007 * selectDumpableNamespace: policy-setting subroutine
2008 * Mark a namespace as to be dumped or not
2009 */
2010static void
2012{
2013 /*
2014 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
2015 * and (for --clean) a DROP SCHEMA statement. (In the absence of
2016 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
2017 */
2019
2020 /*
2021 * If specific tables are being dumped, do not dump any complete
2022 * namespaces. If specific namespaces are being dumped, dump just those
2023 * namespaces. Otherwise, dump all non-system namespaces.
2024 */
2030 nsinfo->dobj.catId.oid) ?
2034 {
2035 /*
2036 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
2037 * they are interesting (and not the original ACLs which were set at
2038 * initdb time, see pg_init_privs).
2039 */
2041 }
2044 {
2045 /* Other system schemas don't get dumped */
2047 }
2049 {
2050 /*
2051 * The public schema is a strange beast that sits in a sort of
2052 * no-mans-land between being a system object and a user object.
2053 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
2054 * a comment and an indication of ownership. If the owner is the
2055 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
2056 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
2057 */
2063
2064 /*
2065 * Also, make like it has a comment even if it doesn't; this is so
2066 * that we'll emit a command to drop the comment, if appropriate.
2067 * (Without this, we'd not call dumpCommentExtended for it.)
2068 */
2070 }
2071 else
2073
2074 /*
2075 * In any case, a namespace can be excluded by an exclusion switch
2076 */
2079 nsinfo->dobj.catId.oid))
2081
2082 /*
2083 * If the schema belongs to an extension, allow extension membership to
2084 * override the dump decision for the schema itself. However, this does
2085 * not change dump_contains, so this won't change what we do with objects
2086 * within the schema. (If they belong to the extension, they'll get
2087 * suppressed by it, otherwise not.)
2088 */
2090}
2091
2092/*
2093 * selectDumpableTable: policy-setting subroutine
2094 * Mark a table as to be dumped or not
2095 */
2096static void
2098{
2100 return; /* extension membership overrides all else */
2101
2102 /*
2103 * If specific tables are being dumped, dump just those tables; else, dump
2104 * according to the parent namespace's dump flag.
2105 */
2108 tbinfo->dobj.catId.oid) ?
2110 else
2112
2113 /*
2114 * In any case, a table can be excluded by an exclusion switch
2115 */
2118 tbinfo->dobj.catId.oid))
2120}
2121
2122/*
2123 * selectDumpableType: policy-setting subroutine
2124 * Mark a type as to be dumped or not
2125 *
2126 * If it's a table's rowtype or an autogenerated array type, we also apply a
2127 * special type code to facilitate sorting into the desired order. (We don't
2128 * want to consider those to be ordinary types because that would bring tables
2129 * up into the datatype part of the dump order.) We still set the object's
2130 * dump flag; that's not going to cause the dummy type to be dumped, but we
2131 * need it so that casts involving such types will be dumped correctly -- see
2132 * dumpCast. This means the flag should be set the same as for the underlying
2133 * object (the table or base type).
2134 */
2135static void
2137{
2138 /* skip complex types, except for standalone composite types */
2141 {
2143
2147 else
2149 return;
2150 }
2151
2152 /* skip auto-generated array and multirange types */
2154 {
2156
2157 /*
2158 * Fall through to set the dump flag; we assume that the subsequent
2159 * rules will do the same thing as they would for the array's base
2160 * type or multirange's range type. (We cannot reliably look up the
2161 * base type here, since getTypes may not have processed it yet.)
2162 */
2163 }
2164
2166 return; /* extension membership overrides all else */
2167
2168 /* Dump based on if the contents of the namespace are being dumped */
2170}
2171
2172/*
2173 * selectDumpableDefaultACL: policy-setting subroutine
2174 * Mark a default ACL as to be dumped or not
2175 *
2176 * For per-schema default ACLs, dump if the schema is to be dumped.
2177 * Otherwise dump if we are dumping "everything". Note that dumpSchema
2178 * and aclsSkip are checked separately.
2179 */
2180static void
2182{
2183 /* Default ACLs can't be extension members */
2184
2186 /* default ACLs are considered part of the namespace */
2188 else
2191}
2192
2193/*
2194 * selectDumpableCast: policy-setting subroutine
2195 * Mark a cast as to be dumped or not
2196 *
2197 * Casts do not belong to any particular namespace (since they haven't got
2198 * names), nor do they have identifiable owners. To distinguish user-defined
2199 * casts from built-in ones, we must resort to checking whether the cast's
2200 * OID is in the range reserved for initdb.
2201 */
2202static void
2204{
2206 return; /* extension membership overrides all else */
2207
2208 /*
2209 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
2210 * support ACLs currently.
2211 */
2214 else
2217}
2218
2219/*
2220 * selectDumpableProcLang: policy-setting subroutine
2221 * Mark a procedural language as to be dumped or not
2222 *
2223 * Procedural languages do not belong to any particular namespace. To
2224 * identify built-in languages, we must resort to checking whether the
2225 * language's OID is in the range reserved for initdb.
2226 */
2227static void
2229{
2231 return; /* extension membership overrides all else */
2232
2233 /*
2234 * Only include procedural languages when we are dumping everything.
2235 *
2236 * For from-initdb procedural languages, only include ACLs, as we do for
2237 * the pg_catalog namespace. We need this because procedural languages do
2238 * not live in any namespace.
2239 */
2242 else
2243 {
2247 else
2249 }
2250}
2251
2252/*
2253 * selectDumpableAccessMethod: policy-setting subroutine
2254 * Mark an access method as to be dumped or not
2255 *
2256 * Access methods do not belong to any particular namespace. To identify
2257 * built-in access methods, we must resort to checking whether the
2258 * method's OID is in the range reserved for initdb.
2259 */
2260static void
2262{
2263 /* see getAccessMethods() comment about v9.6. */
2265 {
2267 return;
2268 }
2269
2271 return; /* extension membership overrides all else */
2272
2273 /*
2274 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
2275 * they do not support ACLs currently.
2276 */
2279 else
2282}
2283
2284/*
2285 * selectDumpableExtension: policy-setting subroutine
2286 * Mark an extension as to be dumped or not
2287 *
2288 * Built-in extensions should be skipped except for checking ACLs, since we
2289 * assume those will already be installed in the target database. We identify
2290 * such extensions by their having OIDs in the range reserved for initdb.
2291 * We dump all user-added extensions by default. No extensions are dumped
2292 * if include_everything is false (i.e., a --schema or --table switch was
2293 * given), except if --extension specifies a list of extensions to dump.
2294 */
2295static void
2297{
2298 /*
2299 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2300 * change permissions on their member objects, if they wish to, and have
2301 * those changes preserved.
2302 */
2305 else
2306 {
2307 /* check if there is a list of extensions to dump */
2311 extinfo->dobj.catId.oid) ?
2313 else
2315 dopt->include_everything ?
2317
2318 /* check that the extension is not explicitly excluded */
2321 extinfo->dobj.catId.oid))
2323 }
2324}
2325
2326/*
2327 * selectDumpablePublicationObject: policy-setting subroutine
2328 * Mark a publication object as to be dumped or not
2329 *
2330 * A publication can have schemas and tables which have schemas, but those are
2331 * ignored in decision making, because publications are only dumped when we are
2332 * dumping everything.
2333 */
2334static void
2336{
2338 return; /* extension membership overrides all else */
2339
2342}
2343
2344/*
2345 * selectDumpableStatisticsObject: policy-setting subroutine
2346 * Mark an extended statistics object as to be dumped or not
2347 *
2348 * We dump an extended statistics object if the schema it's in and the table
2349 * it's for are being dumped. (This'll need more thought if statistics
2350 * objects ever support cross-table stats.)
2351 */
2352static void
2354{
2356 return; /* extension membership overrides all else */
2357
2362}
2363
2364/*
2365 * selectDumpableObject: policy-setting subroutine
2366 * Mark a generic dumpable object as to be dumped or not
2367 *
2368 * Use this only for object types without a special-case routine above.
2369 */
2370static void
2372{
2374 return; /* extension membership overrides all else */
2375
2376 /*
2377 * Default policy is to dump if parent namespace is dumpable, or for
2378 * non-namespace-associated items, dump if we're dumping "everything".
2379 */
2380 if (dobj->namespace)
2382 else
2385}
2386
2387/*
2388 * Dump a table's contents for loading using the COPY command
2389 * - this routine is called by the Archiver when it wants the table
2390 * to be dumped.
2391 */
2392static int
2394{
2399
2400 /*
2401 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2402 * which uses it already.
2403 */
2406 PGresult *res;
2407 int ret;
2410
2412 tbinfo->dobj.namespace->dobj.name, classname);
2413
2414 /*
2415 * Specify the column list explicitly so that we have no possibility of
2416 * retrieving data in the wrong column order. (The default column
2417 * ordering of COPY will not be what we want in certain corner cases
2418 * involving ADD COLUMN and inheritance.)
2419 */
2421
2422 /*
2423 * Use COPY (SELECT ...) TO when dumping a foreign table's data, and when
2424 * a filter condition was specified. For other cases a simple COPY
2425 * suffices.
2426 */
2428 {
2429 /* Temporary allows to access to foreign tables to dump data */
2432
2434 /* klugery to get rid of parens in column list */
2436 {
2439 }
2440 else
2442
2446 }
2447 else
2448 {
2451 column_list);
2452 }
2454 PQclear(res);
2456
2457 for (;;)
2458 {
2460
2461 if (ret < 0)
2462 break; /* done or error */
2463
2465 {
2468 }
2469
2470 /* ----------
2471 * THROTTLE:
2472 *
2473 * There was considerable discussion in late July, 2000 regarding
2474 * slowing down pg_dump when backing up large tables. Users with both
2475 * slow & fast (multi-processor) machines experienced performance
2476 * degradation when doing a backup.
2477 *
2478 * Initial attempts based on sleeping for a number of ms for each ms
2479 * of work were deemed too complex, then a simple 'sleep in each loop'
2480 * implementation was suggested. The latter failed because the loop
2481 * was too tight. Finally, the following was implemented:
2482 *
2483 * If throttle is non-zero, then
2484 * See how long since the last sleep.
2485 * Work out how long to sleep (based on ratio).
2486 * If sleep is more than 100ms, then
2487 * sleep
2488 * reset timer
2489 * EndIf
2490 * EndIf
2491 *
2492 * where the throttle value was the number of ms to sleep per ms of
2493 * work. The calculation was done in each loop.
2494 *
2495 * Most of the hard work is done in the backend, and this solution
2496 * still did not work particularly well: on slow machines, the ratio
2497 * was 50:1, and on medium paced machines, 1:1, and on fast
2498 * multi-processor machines, it had little or no effect, for reasons
2499 * that were unclear.
2500 *
2501 * Further discussion ensued, and the proposal was dropped.
2502 *
2503 * For those people who want this feature, it can be implemented using
2504 * gettimeofday in each loop, calculating the time since last sleep,
2505 * multiplying that by the sleep ratio, then if the result is more
2506 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2507 * function to sleep for a subsecond period ie.
2508 *
2509 * select(0, NULL, NULL, NULL, &tvi);
2510 *
2511 * This will return after the interval specified in the structure tvi.
2512 * Finally, call gettimeofday again to save the 'last sleep time'.
2513 * ----------
2514 */
2515 }
2517
2518 if (ret == -2)
2519 {
2520 /* copy data transfer failed */
2521 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2524 exit_nicely(1);
2525 }
2526
2527 /* Check command status and return to normal libpq state */
2530 {
2534 exit_nicely(1);
2535 }
2536 PQclear(res);
2537
2538 /* Do this to ensure we've pumped libpq back to idle state */
2541 classname);
2542
2543 destroyPQExpBuffer(q);
2544
2545 /* Revert back the setting */
2548
2549 return 1;
2550}
2551
2552/*
2553 * Dump table data using INSERT commands.
2554 *
2555 * Caution: when we restore from an archive file direct to database, the
2556 * INSERT commands emitted by this function have to be parsed by
2557 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
2558 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
2559 */
2560static int
2562{
2568 char *attgenerated;
2569 PGresult *res;
2570 int nfields,
2571 i;
2574
2575 /* Temporary allows to access to foreign tables to dump data */
2578
2579 /*
2580 * If we're going to emit INSERTs with column names, the most efficient
2581 * way to deal with generated columns is to exclude them entirely. For
2582 * INSERTs without column names, we have to emit DEFAULT rather than the
2583 * actual column value --- but we can save a few cycles by fetching nulls
2584 * rather than the uninteresting-to-us value.
2585 */
2588 nfields = 0;
2590 {
2592 continue;
2594 continue;
2595 if (nfields > 0)
2599 else
2602 nfields++;
2603 }
2604 /* Servers before 9.4 will complain about zero-column SELECT */
2605 if (nfields == 0)
2611
2613
2614 while (1)
2615 {
2617 PGRES_TUPLES_OK);
2618
2619 /* cross-check field count, allowing for dummy NULL if any */
2621 !(nfields == 0 && PQnfields(res) == 1))
2623 tbinfo->dobj.name);
2624
2625 /*
2626 * First time through, we build as much of the INSERT statement as
2627 * possible in "insertStmt", which we can then just print for each
2628 * statement. If the table happens to have zero dumpable columns then
2629 * this will be a complete statement, otherwise it will end in
2630 * "VALUES" and be ready to have the row's column values printed.
2631 */
2633 {
2635
2637
2638 /*
2639 * When load-via-partition-root is set or forced, get the root
2640 * table name for the partition table, so that we can reload data
2641 * through the root table.
2642 */
2644 (dopt->load_via_partition_root ||
2647 else
2649
2652
2653 /* corner case for zero-column table */
2654 if (nfields == 0)
2655 {
2657 }
2658 else
2659 {
2660 /* append the list of column names if required */
2662 {
2664 for (int field = 0; field < nfields; field++)
2665 {
2666 if (field > 0)
2670 }
2672 }
2673
2676
2678 }
2679 }
2680
2682 {
2683 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2686
2687 /*
2688 * If it is zero-column table then we've already written the
2689 * complete statement, which will mean we've disobeyed
2690 * --rows-per-insert when it's set greater than 1. We do support
2691 * a way to make this multi-row with: SELECT UNION ALL SELECT
2692 * UNION ALL ... but that's non-standard so we should avoid it
2693 * given that using INSERTs is mostly only ever needed for
2694 * cross-database exports.
2695 */
2696 if (nfields == 0)
2697 continue;
2698
2699 /* Emit a row heading */
2704 else
2706
2707 for (int field = 0; field < nfields; field++)
2708 {
2709 if (field > 0)
2711 if (attgenerated[field])
2712 {
2714 continue;
2715 }
2717 {
2719 continue;
2720 }
2721
2722 /* XXX This code is partially duplicated in ruleutils.c */
2724 {
2732 {
2733 /*
2734 * These types are printed without quotes unless
2735 * they contain values that aren't accepted by the
2736 * scanner unquoted (e.g., 'NaN'). Note that
2737 * strtod() and friends might accept NaN, so we
2738 * can't use that to test.
2739 *
2740 * In reality we only need to defend against
2741 * infinity and NaN, so we need not get too crazy
2742 * about pattern matching here.
2743 */
2745
2748 else
2750 }
2751 break;
2752
2756 PQgetvalue(res, tuple, field));
2757 break;
2758
2762 else
2764 break;
2765
2766 default:
2767 /* All other types are printed as string literals. */
2768 resetPQExpBuffer(q);
2769 appendStringLiteralAH(q,
2770 PQgetvalue(res, tuple, field),
2771 fout);
2773 break;
2774 }
2775 }
2776
2777 /* Terminate the row ... */
2779
2780 /* ... and the statement, if the target no. of rows is reached */
2782 {
2785 else
2787 /* Reset the row counter */
2788 rows_this_statement = 0;
2789 }
2790 }
2791
2793 {
2794 PQclear(res);
2795 break;
2796 }
2797 PQclear(res);
2798 }
2799
2800 /* Terminate any statements that didn't make the row count. */
2802 {
2805 else
2807 }
2808
2810
2812
2813 destroyPQExpBuffer(q);
2816 free(attgenerated);
2817
2818 /* Revert back the setting */
2821
2822 return 1;
2823}
2824
2825/*
2826 * getRootTableInfo:
2827 * get the root TableInfo for the given partition table.
2828 */
2831{
2833
2836
2839 {
2842 }
2843
2845}
2846
2847/*
2848 * forcePartitionRootLoad
2849 * Check if we must force load_via_partition_root for this partition.
2850 *
2851 * This is required if any level of ancestral partitioned table has an
2852 * unsafe partitioning scheme.
2853 */
2854static bool
2856{
2858
2861
2864 return true;
2866 {
2870 return true;
2871 }
2872
2873 return false;
2874}
2875
2876/*
2877 * dumpTableData -
2878 * dump the contents of a single table
2879 *
2880 * Actually, this just makes an ArchiveEntry for the table contents.
2881 */
2882static void
2884{
2889 DataDumperPtr dumpFn;
2891 char *copyStmt;
2893
2894 /* We had better have loaded per-column details about this table */
2896
2897 /*
2898 * When load-via-partition-root is set or forced, get the root table name
2899 * for the partition table, so that we can reload data through the root
2900 * table. Then construct a comment to be inserted into the TOC entry's
2901 * defn field, so that such cases can be identified reliably.
2902 */
2904 (dopt->load_via_partition_root ||
2906 {
2909
2914 sanitized);
2917 }
2918 else
2920
2922 {
2923 /* Dump/restore using COPY */
2924 dumpFn = dumpTableData_copy;
2925 /* must use 2 steps here 'cause fmtId is nonreentrant */
2927 copyFrom);
2930 copyStmt = copyBuf->data;
2931 }
2932 else
2933 {
2934 /* Restore using INSERT */
2935 dumpFn = dumpTableData_insert;
2936 copyStmt = NULL;
2937 }
2938
2939 /*
2940 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2941 * dependency on its table as "special" and pass it to ArchiveEntry now.
2942 * See comments for BuildArchiveDependencies.
2943 */
2945 {
2946 TocEntry *te;
2947
2950 .namespace = tbinfo->dobj.namespace->dobj.name,
2951 .owner = tbinfo->rolname,
2952 .description = "TABLE DATA",
2953 .section = SECTION_DATA,
2954 .createStmt = tdDefn,
2955 .copyStmt = copyStmt,
2956 .deps = &(tbinfo->dobj.dumpId),
2957 .nDeps = 1,
2958 .dumpFn = dumpFn,
2959 .dumpArg = tdinfo));
2960
2961 /*
2962 * Set the TocEntry's dataLength in case we are doing a parallel dump
2963 * and want to order dump jobs by table size. We choose to measure
2964 * dataLength in table pages (including TOAST pages) during dump, so
2965 * no scaling is needed.
2966 *
2967 * However, relpages is declared as "integer" in pg_class, and hence
2968 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2969 * Cast so that we get the right interpretation of table sizes
2970 * exceeding INT_MAX pages.
2971 */
2974
2975 /*
2976 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2977 * and instead we'd better worry about integer overflow. Clamp to
2978 * INT_MAX if the correct result exceeds that.
2979 */
2980 if (sizeof(te->dataLength) == 4 &&
2982 te->dataLength < 0))
2983 te->dataLength = INT_MAX;
2984 }
2985
2988}
2989
2990/*
2991 * refreshMatViewData -
2992 * load or refresh the contents of a single materialized view
2993 *
2994 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2995 * statement.
2996 */
2997static void
2999{
3001 PQExpBuffer q;
3002
3003 /* If the materialized view is not flagged as populated, skip this. */
3005 return;
3006
3007 q = createPQExpBuffer();
3008
3011
3017 .namespace = tbinfo->dobj.namespace->dobj.name,
3018 .owner = tbinfo->rolname,
3019 .description = "MATERIALIZED VIEW DATA",
3020 .section = SECTION_POST_DATA,
3021 .createStmt = q->data,
3022 .deps = tdinfo->dobj.dependencies,
3023 .nDeps = tdinfo->dobj.nDeps));
3024
3025 destroyPQExpBuffer(q);
3026}
3027
3028/*
3029 * getTableData -
3030 * set up dumpable objects representing the contents of tables
3031 */
3032static void
3034{
3036
3038 {
3040 (!relkind || tblinfo[i].relkind == relkind))
3042 }
3043}
3044
3045/*
3046 * Make a dumpable object for the data of this specific table
3047 *
3048 * Note: we make a TableDataInfo if and only if we are going to dump the
3049 * table data; the "dump" field in such objects isn't very interesting.
3050 */
3051static void
3053{
3055
3056 /*
3057 * Nothing to do if we already decided to dump the table. This will
3058 * happen for "config" tables.
3059 */
3061 return;
3062
3063 /* Skip VIEWs (no data to dump) */
3065 return;
3066 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
3070 tbinfo->foreign_server)))
3071 return;
3072 /* Skip partitioned tables (data in partitions) */
3074 return;
3075
3076 /* Don't dump data in unlogged tables, if so requested */
3078 dopt->no_unlogged_table_data)
3079 return;
3080
3081 /* Check that the data is not explicitly excluded */
3083 tbinfo->dobj.catId.oid))
3084 return;
3085
3086 /* OK, let's dump it */
3088
3093 else
3095
3096 /*
3097 * Note: use tableoid 0 so that this object won't be mistaken for
3098 * something that pg_depend entries apply to.
3099 */
3100 tdinfo->dobj.catId.tableoid = 0;
3108
3109 /* A TableDataInfo contains data, of course */
3111
3113
3114 /*
3115 * Materialized view statistics must be restored after the data, because
3116 * REFRESH MATERIALIZED VIEW replaces the storage and resets the stats.
3117 *
3118 * The dependency is added here because the statistics objects are created
3119 * first.
3120 */
3122 {
3125 }
3126
3127 /* Make sure that we'll collect per-column info for this table. */
3129}
3130
3131/*
3132 * The refresh for a materialized view must be dependent on the refresh for
3133 * any materialized view that this one is dependent on.
3134 *
3135 * This must be called after all the objects are created, but before they are
3136 * sorted.
3137 */
3138static void
3140{
3141 PQExpBuffer query;
3142 PGresult *res;
3143 int ntups,
3144 i;
3146 i_objid,
3147 i_refobjid;
3148
3149 /* No Mat Views before 9.3. */
3151 return;
3152
3153 query = createPQExpBuffer();
3154
3156 "( "
3157 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3158 "FROM pg_depend d1 "
3159 "JOIN pg_class c1 ON c1.oid = d1.objid "
3161 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3162 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3163 "AND d2.objid = r1.oid "
3164 "AND d2.refobjid <> d1.objid "
3165 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3168 "WHERE d1.classid = 'pg_class'::regclass "
3169 "UNION "
3170 "SELECT w.objid, d3.refobjid, c3.relkind "
3171 "FROM w "
3172 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3173 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3174 "AND d3.objid = r3.oid "
3175 "AND d3.refobjid <> w.refobjid "
3176 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3179 ") "
3180 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3181 "FROM w "
3183
3185
3186 ntups = PQntuples(res);
3187
3191
3193 {
3194 CatalogId objId;
3196 DumpableObject *dobj;
3200
3205
3206 dobj = findObjectByCatalogId(objId);
3208 continue;
3209
3215 continue;
3217
3220 continue;
3221
3227 continue;
3229
3231
3234 }
3235
3236 PQclear(res);
3237
3238 destroyPQExpBuffer(query);
3239}
3240
3241/*
3242 * getTableDataFKConstraints -
3243 * add dump-order dependencies reflecting foreign key constraints
3244 *
3245 * This code is executed only in a data-only dump --- in schema+data dumps
3246 * we handle foreign key issues by not creating the FK constraints until
3247 * after the data is loaded. In a data-only dump, however, we want to
3248 * order the table data objects in such a way that a table's referenced
3249 * tables are restored first. (In the presence of circular references or
3250 * self-references this may be impossible; we'll detect and complain about
3251 * that during the dependency sorting step.)
3252 */
3253static void
3255{
3259
3260 /* Search through all the dumpable objects for FK constraints */
3263 {
3265 {
3268
3269 /* Not interesting unless both tables are to be dumped */
3272 continue;
3276 continue;
3277
3278 /*
3279 * Okay, make referencing table's TABLE_DATA object depend on the
3280 * referenced table's TABLE_DATA object.
3281 */
3283 ftable->dataObj->dobj.dumpId);
3284 }
3285 }
3287}
3288
3289
3290/*
3291 * dumpDatabase:
3292 * dump the database definition
3293 */
3294static void
3296{
3303 PGresult *res;
3305 i_oid,
3306 i_datname,
3307 i_datdba,
3308 i_encoding,
3309 i_datlocprovider,
3310 i_collate,
3311 i_ctype,
3312 i_datlocale,
3313 i_daticurules,
3314 i_frozenxid,
3315 i_minmxid,
3316 i_datacl,
3317 i_acldefault,
3318 i_datistemplate,
3319 i_datconnlimit,
3320 i_datcollversion,
3321 i_tablespace;
3326 *dba,
3327 *encoding,
3328 *datlocprovider,
3329 *collate,
3330 *ctype,
3331 *locale,
3332 *icurules,
3333 *datistemplate,
3334 *datconnlimit,
3335 *tablespace;
3336 uint32 frozenxid,
3337 minmxid;
3339
3341
3342 /*
3343 * Fetch the database-level properties for this database.
3344 */
3346 "datdba, "
3347 "pg_encoding_to_char(encoding) AS encoding, "
3348 "datcollate, datctype, datfrozenxid, "
3349 "datacl, acldefault('d', datdba) AS acldefault, "
3350 "datistemplate, datconnlimit, ");
3353 else
3359 else
3360 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
3363 else
3366 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3367 "shobj_description(oid, 'pg_database') AS description "
3368 "FROM pg_database "
3369 "WHERE datname = current_database()");
3370
3372
3391
3402 else
3403 locale = NULL;
3406 else
3415
3417
3418 /*
3419 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3420 * to preserve that), as well as the encoding, locale, and tablespace
3421 * since those can't be altered later. Other DB properties are left to
3422 * the DATABASE PROPERTIES entry, so that they can be applied after
3423 * reconnecting to the target DB.
3424 *
3425 * For binary upgrade, we use the FILE_COPY strategy because testing has
3426 * shown it to be faster. When the server is in binary upgrade mode, it
3427 * will also skip the checkpoints this strategy ordinarily performs.
3428 */
3430 {
3432 "CREATE DATABASE %s WITH TEMPLATE = template0 "
3433 "OID = %u STRATEGY = FILE_COPY",
3435 }
3436 else
3437 {
3439 qdatname);
3440 }
3442 {
3445 }
3446
3454 else
3456 datlocprovider);
3457
3459 {
3462 }
3463 else
3464 {
3466 {
3469 }
3471 {
3474 }
3475 }
3476 if (locale)
3477 {
3480 else
3482
3484 }
3485
3487 {
3490 }
3491
3492 /*
3493 * For binary upgrade, carry over the collation version. For normal
3494 * dump/restore, omit the version, so that it is computed upon restore.
3495 */
3497 {
3499 {
3503 fout);
3504 }
3505 }
3506
3507 /*
3508 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3509 * thing; the decision whether to specify a tablespace should be left till
3510 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3511 * label the DATABASE entry with the tablespace and let the normal
3512 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3513 * attention to default_tablespace, so that won't work.
3514 */
3516 !dopt->outputNoTablespaces)
3520
3522 qdatname);
3523
3525
3530 .owner = dba,
3532 .section = SECTION_PRE_DATA,
3534 .dropStmt = delQry->data));
3535
3536 /* Compute correct tag for archive entry */
3538
3539 /* Dump DB comment if any */
3540 {
3541 /*
3542 * 8.2 and up keep comments on shared objects in a shared table, so we
3543 * cannot use the dumpComment() code used for other database objects.
3544 * Be careful that the ArchiveEntry parameters match that function.
3545 */
3547
3549 {
3551
3552 /*
3553 * Generates warning when loaded into a differently-named
3554 * database.
3555 */
3559
3562 .owner = dba,
3563 .description = "COMMENT",
3564 .section = SECTION_NONE,
3565 .createStmt = dbQry->data,
3566 .deps = &dbDumpId,
3567 .nDeps = 1));
3568 }
3569 }
3570
3571 /* Dump DB security label, if enabled */
3573 {
3576
3578
3586 .owner = dba,
3587 .description = "SECURITY LABEL",
3588 .section = SECTION_NONE,
3589 .createStmt = seclabelQry->data,
3590 .deps = &dbDumpId,
3591 .nDeps = 1));
3594 }
3595
3596 /*
3597 * Dump ACL if any. Note that we do not support initial privileges
3598 * (pg_init_privs) on databases.
3599 */
3600 dbdacl.privtype = 0;
3602
3606
3607 /*
3608 * Now construct a DATABASE PROPERTIES archive entry to restore any
3609 * non-default database-level properties. (The reason this must be
3610 * separate is that we cannot put any additional commands into the TOC
3611 * entry that has CREATE DATABASE. pg_restore would execute such a group
3612 * in an implicit transaction block, and the backend won't allow CREATE
3613 * DATABASE in that context.)
3614 */
3617
3621
3623 {
3625 qdatname);
3626
3627 /*
3628 * The backend won't accept DROP DATABASE on a template database. We
3629 * can deal with that by removing the template marking before the DROP
3630 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3631 * since no such command is currently supported, fake it with a direct
3632 * UPDATE on pg_database.
3633 */
3635 "SET datistemplate = false WHERE datname = ");
3638 }
3639
3640 /*
3641 * We do not restore pg_database.dathasloginevt because it is set
3642 * automatically on login event trigger creation.
3643 */
3644
3645 /* Add database-specific SET options */
3647
3648 /*
3649 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3650 * entry, too, for lack of a better place.
3651 */
3653 {
3656 "SET datfrozenxid = '%u', datminmxid = '%u'\n"
3657 "WHERE datname = ",
3658 frozenxid, minmxid);
3661 }
3662
3666 .owner = dba,
3668 .section = SECTION_PRE_DATA,
3670 .dropStmt = delQry->data,
3671 .deps = &dbDumpId));
3672
3673 /*
3674 * pg_largeobject comes from the old system intact, so set its
3675 * relfrozenxids, relminmxids and relfilenode.
3676 *
3677 * pg_largeobject_metadata also comes from the old system intact for
3678 * upgrades from v16 and newer, so set its relfrozenxids, relminmxids, and
3679 * relfilenode, too. pg_upgrade can't copy/link the files from older
3680 * versions because aclitem (needed by pg_largeobject_metadata.lomacl)
3681 * changed its storage format in v16.
3682 */
3684 {
3692 ii_relfilenode,
3693 ii_oid,
3694 ii_relminmxid;
3695
3698 "FROM pg_catalog.pg_class\n"
3699 "WHERE oid IN (%u, %u, %u, %u);\n",
3702 else
3704 "FROM pg_catalog.pg_class\n"
3705 "WHERE oid IN (%u, %u);\n",
3707
3709
3714
3715 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3716 appendPQExpBufferStr(lomHorizonQry, "\n-- For binary upgrade, set pg_largeobject_metadata relfrozenxid and relminmxid\n");
3717 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3718 appendPQExpBufferStr(lomOutQry, "\n-- For binary upgrade, preserve pg_largeobject_metadata and index relfilenodes\n");
3720 {
3721 Oid oid;
3722 RelFileNumber relfilenumber;
3725
3728
3730 oid == LargeObjectLOidPNIndexId)
3731 {
3734 }
3735 else
3736 {
3739 }
3740
3742 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
3743 "WHERE oid = %u;\n",
3747
3749 oid == LargeObjectMetadataRelationId)
3751 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
3752 relfilenumber);
3754 oid == LargeObjectMetadataOidIndexId)
3756 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
3757 relfilenumber);
3758 }
3759
3761 "TRUNCATE pg_catalog.pg_largeobject;\n");
3763 "TRUNCATE pg_catalog.pg_largeobject_metadata;\n");
3764
3767
3771 .section = SECTION_PRE_DATA,
3772 .createStmt = loOutQry->data));
3773
3778 .section = SECTION_PRE_DATA,
3779 .createStmt = lomOutQry->data));
3780
3782
3788 }
3789
3790 PQclear(res);
3791
3797}
3798
3799/*
3800 * Collect any database-specific or role-and-database-specific SET options
3801 * for this database, and append them to outbuf.
3802 */
3803static void
3806{
3809 PGresult *res;
3810
3811 /* First collect database-specific options */
3813 "WHERE setrole = 0 AND setdatabase = '%u'::oid",
3814 dboid);
3815
3817
3821 outbuf);
3822
3823 PQclear(res);
3824
3825 /* Now look for role-and-database-specific options */
3827 "FROM pg_db_role_setting s, pg_roles r "
3828 "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
3829 dboid);
3830
3832
3837 outbuf);
3838
3839 PQclear(res);
3840
3842}
3843
3844/*
3845 * dumpEncoding: put the correct encoding into the archive
3846 */
3847static void
3849{
3852
3854
3858
3862 .section = SECTION_PRE_DATA,
3863 .createStmt = qry->data));
3864
3865 destroyPQExpBuffer(qry);
3866}
3867
3868
3869/*
3870 * dumpStdStrings: put the correct escape string behavior into the archive
3871 */
3872static void
3874{
3877
3879 stdstrings);
3880
3882 stdstrings);
3883
3887 .section = SECTION_PRE_DATA,
3888 .createStmt = qry->data));
3889
3890 destroyPQExpBuffer(qry);
3891}
3892
3893/*
3894 * dumpSearchPath: record the active search_path in the archive
3895 */
3896static void
3898{
3901 PGresult *res;
3905
3906 /*
3907 * We use the result of current_schemas(), not the search_path GUC,
3908 * because that might contain wildcards such as "$user", which won't
3909 * necessarily have the same value during restore. Also, this way avoids
3910 * listing schemas that may appear in search_path but not actually exist,
3911 * which seems like a prudent exclusion.
3912 */
3913 res = ExecuteSqlQueryForSingleRow(AH,
3914 "SELECT pg_catalog.current_schemas(false)");
3915
3918
3919 /*
3920 * We use set_config(), not a simple "SET search_path" command, because
3921 * the latter has less-clean behavior if the search path is empty. While
3922 * that's likely to get fixed at some point, it seems like a good idea to
3923 * be as backwards-compatible as possible in what we put into archives.
3924 */
3926 {
3930 }
3931
3935
3937
3941 .section = SECTION_PRE_DATA,
3942 .createStmt = qry->data));
3943
3944 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3946
3948 PQclear(res);
3949 destroyPQExpBuffer(qry);
3950 destroyPQExpBuffer(path);
3951}
3952
3953
3954/*
3955 * getLOs:
3956 * Collect schema-level data about large objects
3957 */
3958static void
3960{
3963 PGresult *res;
3964 int ntups;
3966 int n;
3971
3973
3974 /*
3975 * Fetch LO OIDs and owner/ACL data. Order the data so that all the blobs
3976 * with the same owner/ACL appear together.
3977 */
3979 "SELECT oid, lomowner, lomacl, "
3980 "acldefault('L', lomowner) AS acldefault "
3981 "FROM pg_largeobject_metadata "
3982 "ORDER BY lomowner, lomacl::pg_catalog.text, oid");
3983
3985
3990
3991 ntups = PQntuples(res);
3992
3993 /*
3994 * Group the blobs into suitably-sized groups that have the same owner and
3995 * ACL setting, and build a metadata and a data DumpableObject for each
3996 * group. (If we supported initprivs for blobs, we'd have to insist that
3997 * groups also share initprivs settings, since the DumpableObject only has
3998 * room for one.) i is the index of the first tuple in the current group,
3999 * and n is the number of tuples we include in the group.
4000 */
4002 {
4009
4010 /* Scan to find first tuple not to be included in group */
4011 n = 1;
4013 {
4016 break;
4017 n++;
4018 }
4019
4020 /* Build the metadata DumpableObject */
4022
4027
4028 if (n > 1)
4031 else
4036 loinfo->dacl.privtype = 0;
4039 loinfo->numlos = n;
4041 /* Collect OIDs of the remaining blobs in this group */
4042 for (int k = 1; k < n; k++)
4043 {
4045
4047
4048 /* Make sure we can look up loinfo by any of the blobs' OIDs */
4052 }
4053
4054 /* LOs have data */
4056
4057 /* Mark whether LO group has a non-empty ACL */
4060
4061 /*
4062 * In binary-upgrade mode for LOs, we do *not* dump out the LO data,
4063 * as it will be copied by pg_upgrade, which simply copies the
4064 * pg_largeobject table. We *do* however dump out anything but the
4065 * data, as pg_upgrade copies just pg_largeobject, but not
4066 * pg_largeobject_metadata, after the dump is restored. In versions
4067 * before v12, this is done via proper large object commands. In
4068 * newer versions, we dump the content of pg_largeobject_metadata and
4069 * any associated pg_shdepend rows, which is faster to restore. (On
4070 * <v12, pg_largeobject_metadata was created WITH OIDS, so the OID
4071 * column is hidden and won't be dumped.)
4072 */
4074 {
4076 {
4077 /*
4078 * We should've saved pg_largeobject_metadata's dump ID before
4079 * this point.
4080 */
4082
4084
4085 /*
4086 * Mark the large object as dependent on
4087 * pg_largeobject_metadata so that any large object
4088 * comments/seclables are dumped after it.
4089 */
4093 }
4094 else
4096 }
4097
4098 /*
4099 * Create a "BLOBS" data item for the group, too. This is just a
4100 * placeholder for sorting; it carries no data now.
4101 */
4108 /* Set up explicit dependency from data to metadata */
4112 }
4113
4114 PQclear(res);
4116}
4117
4118/*
4119 * dumpLO
4120 *
4121 * dump the definition (metadata) of the given large object group
4122 */
4123static void
4125{
4127
4128 /*
4129 * The "definition" is just a newline-separated list of OIDs. We need to
4130 * put something into the dropStmt too, but it can just be a comment.
4131 */
4134
4138 .owner = loinfo->rolname,
4139 .description = "BLOB METADATA",
4140 .section = SECTION_DATA,
4141 .createStmt = cquery->data,
4142 .dropStmt = "-- dummy"));
4143
4144 /*
4145 * Dump per-blob comments and seclabels if any. We assume these are rare
4146 * enough that it's okay to generate retail TOC entries for them.
4147 */
4149 DUMP_COMPONENT_SECLABEL))
4150 {
4152 {
4153 CatalogId catId;
4155
4156 /* Build identifying info for this blob */
4160
4164 catId, 0, loinfo->dobj.dumpId);
4165
4169 catId, 0, loinfo->dobj.dumpId);
4170 }
4171 }
4172
4173 /*
4174 * Dump the ACLs if any (remember that all blobs in the group will have
4175 * the same ACL). If there's just one blob, dump a simple ACL entry; if
4176 * there's more, make a "LARGE OBJECTS" entry that really contains only
4177 * the ACL for the first blob. _printTocEntry() will be cued by the tag
4178 * string to emit a mutated version for each blob.
4179 */
4181 {
4183
4184 /* Build identifying info for the first blob */
4186
4188 {
4190
4193
4197 }
4198 else
4199 {
4203 }
4204 }
4205
4207}
4208
4209/*
4210 * dumpLOs:
4211 * dump the data contents of the large objects in the given group
4212 */
4213static int
4215{
4219
4221
4223 {
4225 int loFd;
4226 int cnt;
4227
4228 /* Open the LO */
4230 if (loFd == -1)
4233
4235
4236 /* Now read it in chunks, sending data to archive */
4237 do
4238 {
4240 if (cnt < 0)
4243
4245 } while (cnt > 0);
4246
4248
4250 }
4251
4252 return 1;
4253}
4254
4255/*
4256 * getPolicies
4257 * get information about all RLS policies on dumpable tables.
4258 */
4259void
4261{
4263 PQExpBuffer query;
4265 PGresult *res;
4277 j,
4278 ntups;
4279
4280 /* No policies before 9.5 */
4282 return;
4283
4284 /* Skip if --no-policies was specified */
4286 return;
4287
4288 query = createPQExpBuffer();
4290
4291 /*
4292 * Identify tables of interest, and check which ones have RLS enabled.
4293 */
4296 {
4298
4299 /* Ignore row security on tables not to be dumped */
4301 continue;
4302
4303 /* It can't have RLS or policies if it's not a table */
4306 continue;
4307
4308 /* Add it to the list of table OIDs to be probed below */
4312
4313 /* Is RLS enabled? (That's separate from whether it has policies) */
4315 {
4317
4318 /*
4319 * We represent RLS being enabled on a table by creating a
4320 * PolicyInfo object with null polname.
4321 *
4322 * Note: use tableoid 0 so that this object won't be mistaken for
4323 * something that pg_depend entries apply to.
4324 */
4327 polinfo->dobj.catId.tableoid = 0;
4335 polinfo->polpermissive = 0;
4339 }
4340 }
4342
4343 /*
4344 * Now, read all RLS policies belonging to the tables of interest, and
4345 * create PolicyInfo objects for them. (Note that we must filter the
4346 * results server-side not locally, because we dare not apply pg_get_expr
4347 * to tables we don't have lock on.)
4348 */
4350
4351 printfPQExpBuffer(query,
4352 "SELECT pol.oid, pol.tableoid, pol.polrelid, pol.polname, pol.polcmd, ");
4355 else
4357 appendPQExpBuffer(query,
4358 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
4359 " 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, "
4360 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
4361 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
4362 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
4363 "JOIN pg_catalog.pg_policy pol ON (src.tbloid = pol.polrelid)",
4364 tbloids->data);
4365
4367
4368 ntups = PQntuples(res);
4369 if (ntups > 0)
4370 {
4380
4382
4384 {
4387
4389
4399
4402
4405 else
4407
4410 else
4412
4415 else
4418 }
4419 }
4420
4421 PQclear(res);
4422
4423 destroyPQExpBuffer(query);
4425}
4426
4427/*
4428 * dumpPolicy
4429 * dump the definition of the given policy
4430 */
4431static void
4433{
4436 PQExpBuffer query;
4440 const char *cmd;
4441 char *tag;
4442
4443 /* Do nothing if not dumping schema */
4445 return;
4446
4447 /*
4448 * If polname is NULL, then this record is just indicating that ROW LEVEL
4449 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
4450 * ROW LEVEL SECURITY.
4451 */
4453 {
4454 query = createPQExpBuffer();
4455
4458
4459 /*
4460 * We must emit the ROW SECURITY object's dependency on its table
4461 * explicitly, because it will not match anything in pg_depend (unlike
4462 * the case for other PolicyInfo objects).
4463 */
4467 .namespace = polinfo->dobj.namespace->dobj.name,
4468 .owner = tbinfo->rolname,
4469 .description = "ROW SECURITY",
4470 .section = SECTION_POST_DATA,
4471 .createStmt = query->data,
4472 .deps = &(tbinfo->dobj.dumpId),
4473 .nDeps = 1));
4474
4475 destroyPQExpBuffer(query);
4476 return;
4477 }
4478
4480 cmd = "";
4482 cmd = " FOR SELECT";
4484 cmd = " FOR INSERT";
4486 cmd = " FOR UPDATE";
4488 cmd = " FOR DELETE";
4489 else
4491 polinfo->polcmd);
4492
4493 query = createPQExpBuffer();
4496
4498
4500
4503
4506
4509
4512
4514
4517
4520
4522
4525 ARCHIVE_OPTS(.tag = tag,
4527 .owner = tbinfo->rolname,
4528 .description = "POLICY",
4529 .section = SECTION_POST_DATA,
4530 .createStmt = query->data,
4531 .dropStmt = delqry->data));
4532
4537
4538 free(tag);
4539 destroyPQExpBuffer(query);
4543}
4544
4545/*
4546 * getPublications
4547 * get information about publications
4548 */
4549void
4551{
4553 PQExpBuffer query;
4554 PGresult *res;
4569 ntups;
4570
4572 return;
4573
4574 query = createPQExpBuffer();
4575
4576 /* Get the publications. */
4578 "p.pubowner, p.puballtables, p.pubinsert, "
4579 "p.pubupdate, p.pubdelete, ");
4580
4583 else
4585
4588 else
4590
4593 else
4595
4598 else
4600
4602
4604
4605 ntups = PQntuples(res);
4606
4607 if (ntups == 0)
4609
4622
4624
4626 {
4650
4651 /* Decide whether we want to dump it */
4653 }
4654
4655cleanup:
4656 PQclear(res);
4657
4658 destroyPQExpBuffer(query);
4659}
4660
4661/*
4662 * dumpPublication
4663 * dump the definition of the given publication
4664 */
4665static void
4667{
4670 PQExpBuffer query;
4672 bool first = true;
4673
4674 /* Do nothing if not dumping schema */
4676 return;
4677
4679 query = createPQExpBuffer();
4680
4682
4684 qpubname);
4685
4687 qpubname);
4688
4695
4698 {
4700 first = false;
4701 }
4702
4704 {
4705 if (!first)
4707
4709 first = false;
4710 }
4711
4713 {
4714 if (!first)
4716
4718 first = false;
4719 }
4720
4722 {
4723 if (!first)
4725
4727 first = false;
4728 }
4729
4731
4734
4737
4739
4743 .owner = pubinfo->rolname,
4744 .description = "PUBLICATION",
4745 .section = SECTION_POST_DATA,
4746 .createStmt = query->data,
4747 .dropStmt = delq->data));
4748
4753
4758
4760 destroyPQExpBuffer(query);
4762}
4763
4764/*
4765 * getPublicationNamespaces
4766 * get information about publication membership for dumpable schemas.
4767 */
4768void
4770{
4771 PQExpBuffer query;
4772 PGresult *res;
4780 j,
4781 ntups;
4782
4784 return;
4785
4786 query = createPQExpBuffer();
4787
4788 /* Collect all publication membership info. */
4789 appendPQExpBufferStr(query,
4790 "SELECT tableoid, oid, pnpubid, pnnspid "
4791 "FROM pg_catalog.pg_publication_namespace");
4793
4794 ntups = PQntuples(res);
4795
4800
4801 /* this allocation may be more than we need */
4803 j = 0;
4804
4806 {
4811
4812 /*
4813 * Ignore any entries for which we aren't interested in either the
4814 * publication or the rel.
4815 */
4818 continue;
4821 continue;
4822
4823 /* OK, make a DumpableObject for this relationship */
4833
4834 /* Decide whether we want to dump it */
4836
4837 j++;
4838 }
4839
4840 PQclear(res);
4841 destroyPQExpBuffer(query);
4842}
4843
4844/*
4845 * getPublicationTables
4846 * get information about publication membership for dumpable tables.
4847 */
4848void
4850{
4851 PQExpBuffer query;
4852 PGresult *res;
4862 j,
4863 ntups;
4864
4866 return;
4867
4868 query = createPQExpBuffer();
4869
4870 /* Collect all publication membership info. */
4872 appendPQExpBufferStr(query,
4873 "SELECT tableoid, oid, prpubid, prrelid, "
4874 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4875 "(CASE\n"
4876 " WHEN pr.prattrs IS NOT NULL THEN\n"
4877 " (SELECT array_agg(attname)\n"
4878 " FROM\n"
4879 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4880 " pg_catalog.pg_attribute\n"
4881 " WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
4882 " ELSE NULL END) prattrs "
4883 "FROM pg_catalog.pg_publication_rel pr");
4884 else
4885 appendPQExpBufferStr(query,
4886 "SELECT tableoid, oid, prpubid, prrelid, "
4887 "NULL AS prrelqual, NULL AS prattrs "
4888 "FROM pg_catalog.pg_publication_rel");
4890
4891 ntups = PQntuples(res);
4892
4899
4900 /* this allocation may be more than we need */
4902 j = 0;
4903
4905 {
4910
4911 /*
4912 * Ignore any entries for which we aren't interested in either the
4913 * publication or the rel.
4914 */
4917 continue;
4920 continue;
4921
4922 /* OK, make a DumpableObject for this relationship */
4934 else
4936
4938 {
4939 char **attnames;
4942
4944 &attnames, &nattnames))
4948 {
4949 if (k > 0)
4951
4953 }
4956 free(attnames);
4957 }
4958 else
4960
4961 /* Decide whether we want to dump it */
4963
4964 j++;
4965 }
4966
4967 PQclear(res);
4968 destroyPQExpBuffer(query);
4969}
4970
4971/*
4972 * dumpPublicationNamespace
4973 * dump the definition of the given publication schema mapping.
4974 */
4975static void
4977{
4981 PQExpBuffer query;
4982 char *tag;
4983
4984 /* Do nothing if not dumping schema */
4986 return;
4987
4989
4990 query = createPQExpBuffer();
4991
4994
4995 /*
4996 * There is no point in creating drop query as the drop is done by schema
4997 * drop.
4998 */
5001 ARCHIVE_OPTS(.tag = tag,
5003 .owner = pubinfo->rolname,
5004 .description = "PUBLICATION TABLES IN SCHEMA",
5005 .section = SECTION_POST_DATA,
5006 .createStmt = query->data));
5007
5008 /* These objects can't currently have comments or seclabels */
5009
5010 free(tag);
5011 destroyPQExpBuffer(query);
5012}
5013
5014/*
5015 * dumpPublicationTable
5016 * dump the definition of the given publication table mapping
5017 */
5018static void
5020{
5024 PQExpBuffer query;
5025 char *tag;
5026
5027 /* Do nothing if not dumping schema */
5029 return;
5030
5032
5033 query = createPQExpBuffer();
5034
5039
5042
5044 {
5045 /*
5046 * It's necessary to add parentheses around the expression because
5047 * pg_get_expr won't supply the parentheses for things like WHERE
5048 * TRUE.
5049 */
5051 }
5053
5054 /*
5055 * There is no point in creating a drop query as the drop is done by table
5056 * drop. (If you think to change this, see also _printTocEntry().)
5057 * Although this object doesn't really have ownership as such, set the
5058 * owner field anyway to ensure that the command is run by the correct
5059 * role at restore time.
5060 */
5063 ARCHIVE_OPTS(.tag = tag,
5065 .owner = pubinfo->rolname,
5066 .description = "PUBLICATION TABLE",
5067 .section = SECTION_POST_DATA,
5068 .createStmt = query->data));
5069
5070 /* These objects can't currently have comments or seclabels */
5071
5072 free(tag);
5073 destroyPQExpBuffer(query);
5074}
5075
5076/*
5077 * Is the currently connected user a superuser?
5078 */
5079static bool
5081{
5084
5086
5088 return true;
5089
5090 return false;
5091}
5092
5093/*
5094 * Set the given value to restrict_nonsystem_relation_kind value. Since
5095 * restrict_nonsystem_relation_kind is introduced in minor version releases,
5096 * the setting query is effective only where available.
5097 */
5098static void
5100{
5102 PGresult *res;
5103
5104 appendPQExpBuffer(query,
5105 "SELECT set_config(name, '%s', false) "
5106 "FROM pg_settings "
5107 "WHERE name = 'restrict_nonsystem_relation_kind'",
5108 value);
5110
5111 PQclear(res);
5112 destroyPQExpBuffer(query);
5113}
5114
5115/*
5116 * getSubscriptions
5117 * get information about subscriptions
5118 */
5119void
5121{
5123 PQExpBuffer query;
5124 PGresult *res;
5125 SubscriptionInfo *subinfo;
5147 ntups;
5148
5150 return;
5151
5153 {
5154 int n;
5155
5157 "SELECT count(*) FROM pg_subscription "
5158 "WHERE subdbid = (SELECT oid FROM pg_database"
5159 " WHERE datname = current_database())",
5160 PGRES_TUPLES_OK);
5162 if (n > 0)
5164 PQclear(res);
5165 return;
5166 }
5167
5168 query = createPQExpBuffer();
5169
5170 /* Get the subscriptions in current database. */
5171 appendPQExpBufferStr(query,
5172 "SELECT s.tableoid, s.oid, s.subname,\n"
5173 " s.subowner,\n"
5174 " s.subconninfo, s.subslotname, s.subsynccommit,\n"
5175 " s.subpublications,\n");
5176
5179 else
5181
5184 else
5186
5188 appendPQExpBufferStr(query,
5189 " s.subtwophasestate,\n"
5190 " s.subdisableonerr,\n");
5191 else
5192 appendPQExpBuffer(query,
5193 " '%c' AS subtwophasestate,\n"
5194 " false AS subdisableonerr,\n",
5196
5198 appendPQExpBufferStr(query,
5199 " s.subpasswordrequired,\n"
5200 " s.subrunasowner,\n"
5201 " s.suborigin,\n");
5202 else
5203 appendPQExpBuffer(query,
5204 " 't' AS subpasswordrequired,\n"
5205 " 't' AS subrunasowner,\n"
5206 " '%s' AS suborigin,\n",
5207 LOGICALREP_ORIGIN_ANY);
5208
5211 " s.subenabled,\n");
5212 else
5214 " false AS subenabled,\n");
5215
5217 appendPQExpBufferStr(query,
5218 " s.subfailover,\n");
5219 else
5220 appendPQExpBufferStr(query,
5221 " false AS subfailover,\n");
5222
5224 appendPQExpBufferStr(query,
5225 " s.subretaindeadtuples,\n");
5226 else
5227 appendPQExpBufferStr(query,
5228 " false AS subretaindeadtuples,\n");
5229
5231 appendPQExpBufferStr(query,
5232 " s.submaxretention\n");
5233 else
5234 appendPQExpBuffer(query,
5235 " 0 AS submaxretention\n");
5236
5237 appendPQExpBufferStr(query,
5238 "FROM pg_subscription s\n");
5239
5241 appendPQExpBufferStr(query,
5242 "LEFT JOIN pg_catalog.pg_replication_origin_status o \n"
5243 " ON o.external_id = 'pg_' || s.oid::text \n");
5244
5245 appendPQExpBufferStr(query,
5246 "WHERE s.subdbid = (SELECT oid FROM pg_database\n"
5247 " WHERE datname = current_database())");
5248
5250
5251 ntups = PQntuples(res);
5252
5253 /*
5254 * Get subscription fields. We don't include subskiplsn in the dump as
5255 * after restoring the dump this value may no longer be relevant.
5256 */
5277
5279
5281 {
5289
5312 else
5322 else
5325
5326 /* Decide whether we want to dump it */
5328 }
5329 PQclear(res);
5330
5331 destroyPQExpBuffer(query);
5332}
5333
5334/*
5335 * getSubscriptionRelations
5336 * Get information about subscription membership for dumpable relations. This
5337 * will be used only in binary-upgrade mode for PG17 or later versions.
5338 */
5339void
5341{
5345 PGresult *res;
5350 int ntups;
5352
5354 fout->remoteVersion < 170000)
5355 return;
5356
5358 "SELECT srsubid, srrelid, srsubstate, srsublsn "
5359 "FROM pg_catalog.pg_subscription_rel "
5360 "ORDER BY srsubid",
5361 PGRES_TUPLES_OK);
5362 ntups = PQntuples(res);
5363 if (ntups == 0)
5365
5366 /* Get pg_subscription_rel attributes */
5371
5374 {
5377 TableInfo *tblinfo;
5378
5379 /*
5380 * If we switched to a new subscription, check if the subscription
5381 * exists.
5382 */
5384 {
5388
5390 }
5391
5392 tblinfo = findTableByOid(relid);
5395 relid);
5396
5397 /* OK, make a DumpableObject for this relationship */
5409 else
5411
5412 /* Decide whether we want to dump it */
5414 }
5415
5416cleanup:
5417 PQclear(res);
5418}
5419
5420/*
5421 * dumpSubscriptionTable
5422 * Dump the definition of the given subscription table mapping. This will be
5423 * used only in binary-upgrade mode for PG17 or later versions.
5424 */
5425static void
5427{
5430 PQExpBuffer query;
5431 char *tag;
5432
5433 /* Do nothing if not dumping schema */
5435 return;
5436
5438
5440
5441 query = createPQExpBuffer();
5442
5444 {
5445 /*
5446 * binary_upgrade_add_sub_rel_state will add the subscription relation
5447 * to pg_subscription_rel table. This will be used only in
5448 * binary-upgrade mode.
5449 */
5450 appendPQExpBufferStr(query,
5451 "\n-- For binary upgrade, must preserve the subscriber table.\n");
5452 appendPQExpBufferStr(query,
5453 "SELECT pg_catalog.binary_upgrade_add_sub_rel_state(");
5455 appendPQExpBuffer(query,
5456 ", %u, '%c'",
5457 subrinfo->tblinfo->dobj.catId.oid,
5458 subrinfo->srsubstate);
5459
5462 else
5464
5466 }
5467
5468 /*
5469 * There is no point in creating a drop query as the drop is done by table
5470 * drop. (If you think to change this, see also _printTocEntry().)
5471 * Although this object doesn't really have ownership as such, set the
5472 * owner field anyway to ensure that the command is run by the correct
5473 * role at restore time.
5474 */
5477 ARCHIVE_OPTS(.tag = tag,
5479 .owner = subinfo->rolname,
5480 .description = "SUBSCRIPTION TABLE",
5481 .section = SECTION_POST_DATA,
5482 .createStmt = query->data));
5483
5484 /* These objects can't currently have comments or seclabels */
5485
5486 free(tag);
5487 destroyPQExpBuffer(query);
5488}
5489
5490/*
5491 * dumpSubscription
5492 * dump the definition of the given subscription
5493 */
5494static void
5496{
5499 PQExpBuffer query;
5500 PQExpBuffer publications;
5505
5506 /* Do nothing if not dumping schema */
5508 return;
5509
5511 query = createPQExpBuffer();
5512
5514
5516 qsubname);
5517
5519 qsubname);
5521
5522 /* Build list of quoted publications and append them to query. */
5525
5526 publications = createPQExpBuffer();
5528 {
5531
5533 }
5534
5535 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
5538 else
5540
5543
5548 else
5550
5553
5556
5559
5562
5565
5568
5571
5574
5577
5579
5580 /*
5581 * In binary-upgrade mode, we allow the replication to continue after the
5582 * upgrade.
5583 */
5585 {
5587 {
5588 /*
5589 * Preserve the remote_lsn for the subscriber's replication
5590 * origin. This value is required to start the replication from
5591 * the position before the upgrade. This value will be stale if
5592 * the publisher gets upgraded before the subscriber node.
5593 * However, this shouldn't be a problem as the upgrade of the
5594 * publisher ensures that all the transactions were replicated
5595 * before upgrading it.
5596 */
5597 appendPQExpBufferStr(query,
5598 "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
5599 appendPQExpBufferStr(query,
5600 "SELECT pg_catalog.binary_upgrade_replorigin_advance(");
5603 }
5604
5606 {
5607 /*
5608 * Enable the subscription to allow the replication to continue
5609 * after the upgrade.
5610 */
5611 appendPQExpBufferStr(query,
5612 "\n-- For binary upgrade, must preserve the subscriber's running state.\n");
5614 }
5615 }
5616
5620 .owner = subinfo->rolname,
5621 .description = "SUBSCRIPTION",
5622 .section = SECTION_POST_DATA,
5623 .createStmt = query->data,
5624 .dropStmt = delq->data));
5625
5630
5635
5636 destroyPQExpBuffer(publications);
5638
5640 destroyPQExpBuffer(query);
5642}
5643
5644/*
5645 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
5646 * the object needs.
5647 */
5648static void
5650 PQExpBuffer create,
5653 const char *keyword,
5654 const char *objname)
5655{
5657 {
5659 PGresult *res;
5660 PQExpBuffer query;
5661 int ntups;
5664
5665 /* dodge fmtId() non-reentrancy */
5667
5668 query = createPQExpBuffer();
5669 appendPQExpBuffer(query,
5670 "SELECT e.extname "
5671 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5672 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5673 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5674 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5675 catalog,
5678 ntups = PQntuples(res);
5681 {
5683 keyword, nm,
5685 }
5686
5687 PQclear(res);
5688 destroyPQExpBuffer(query);
5690 }
5691}
5692
5695{
5696 /*
5697 * If the old version didn't assign an array type, but the new version
5698 * does, we must select an unused type OID to assign. This currently only
5699 * happens for domains, when upgrading pre-v11 to v11 and up.
5700 *
5701 * Note: local state here is kind of ugly, but we must have some, since we
5702 * mustn't choose the same unused OID more than once.
5703 */
5705 PGresult *res;
5707
5708 do
5709 {
5710 ++next_possible_free_oid;
5712 "SELECT EXISTS(SELECT 1 "
5713 "FROM pg_catalog.pg_type "
5714 "WHERE oid = '%u'::pg_catalog.oid);",
5715 next_possible_free_oid);
5718 PQclear(res);
5720
5722}
5723
5724static void
5730{
5732 PGresult *res;
5737
5740 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5741 pg_type_oid);
5742
5746 else
5748
5751
5753 {
5755 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5757 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5758 pg_type_array_oid);
5759 }
5760
5761 /*
5762 * Pre-set the multirange type oid and its own array type oid.
5763 */
5765 {
5767 {
5769 "SELECT t.oid, t.typarray "
5770 "FROM pg_catalog.pg_type t "
5771 "JOIN pg_catalog.pg_range r "
5772 "ON t.oid = r.rngmultitypid "
5773 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5774 pg_type_oid);
5775
5777
5780
5781 PQclear(res);
5782 }
5783 else
5784 {
5787 }
5788
5790 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5792 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5793 pg_type_multirange_oid);
5795 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5797 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5798 pg_type_multirange_array_oid);
5799 }
5800
5802}
5803
5804static void
5808{
5810
5814}
5815
5816/*
5817 * bsearch() comparator for BinaryUpgradeClassOidItem
5818 */
5819static int
5821{
5824
5826}
5827
5828/*
5829 * collectBinaryUpgradeClassOids
5830 *
5831 * Construct a table of pg_class information required for
5832 * binary_upgrade_set_pg_class_oids(). The table is sorted by OID for speed in
5833 * lookup.
5834 */
5835static void
5837{
5838 PGresult *res;
5839 const char *query;
5840
5841 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5842 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5843 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5844 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5845 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5846 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5847 "ORDER BY c.oid;";
5848
5850
5854
5856 {
5864 }
5865
5866 PQclear(res);
5867}
5868
5869static void
5872{
5874 BinaryUpgradeClassOidItem *entry;
5875
5877
5878 /*
5879 * Preserve the OID and relfilenumber of the table, table's index, table's
5880 * toast table and toast table's index if any.
5881 *
5882 * One complexity is that the current table definition might not require
5883 * the creation of a TOAST table, but the old database might have a TOAST
5884 * table that was created earlier, before some wide columns were dropped.
5885 * By setting the TOAST oid we force creation of the TOAST heap and index
5886 * by the new backend, so we can copy the files during binary upgrade
5887 * without worrying about this case.
5888 */
5892 BinaryUpgradeClassOidItemCmp);
5893
5895 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5896
5899 {
5901 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5902 pg_class_oid);
5903
5904 /*
5905 * Not every relation has storage. Also, in a pre-v12 database,
5906 * partitioned tables have a relfilenumber, which should not be
5907 * preserved when upgrading.
5908 */
5912 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5913 entry->relfilenumber);
5914
5915 /*
5916 * In a pre-v12 database, partitioned tables might be marked as having
5917 * toast tables, but we should ignore them if so.
5918 */
5921 {
5923 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
5924 entry->toast_oid);
5926 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
5927 entry->toast_relfilenumber);
5928
5929 /* every toast table has an index */
5931 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5932 entry->toast_index_oid);
5934 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5935 entry->toast_index_relfilenumber);
5936 }
5937 }
5938 else
5939 {
5940 /* Preserve the OID and relfilenumber of the index */
5942 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5943 pg_class_oid);
5945 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5946 entry->relfilenumber);
5947 }
5948
5950}
5951
5952/*
5953 * If the DumpableObject is a member of an extension, add a suitable
5954 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
5955 *
5956 * For somewhat historical reasons, objname should already be quoted,
5957 * but not objnamespace (if any).
5958 */
5959static void
5962 const char *objtype,
5963 const char *objname,
5965{
5968
5970 return;
5971
5972 /*
5973 * Find the parent extension. We could avoid this search if we wanted to
5974 * add a link field to DumpableObject, but the space costs of that would
5975 * be considerable. We assume that member objects could only have a
5976 * direct dependency on their own extension, not any others.
5977 */
5979 {
5982 break;
5984 }
5987 objtype, objname);
5988
5990 "\n-- For binary upgrade, handle extension membership the hard way\n");
5993 objtype);
5997}
5998
5999/*
6000 * getNamespaces:
6001 * get information about all namespaces in the system catalogs
6002 */
6003void
6005{
6006 PGresult *res;
6007 int ntups;
6009 PQExpBuffer query;
6017
6018 query = createPQExpBuffer();
6019
6020 /*
6021 * we fetch all namespaces including system ones, so that every object we
6022 * read in can be linked to a containing namespace.
6023 */
6025 "n.nspowner, "
6026 "n.nspacl, "
6027 "acldefault('n', n.nspowner) AS acldefault "
6028 "FROM pg_namespace n");
6029
6031
6032 ntups = PQntuples(res);
6033
6035
6042
6044 {
6045 const char *nspowner;
6046
6059
6060 /* Decide whether to dump this namespace */
6062
6063 /* Mark whether namespace has an ACL */
6066
6067 /*
6068 * We ignore any pg_init_privs.initprivs entry for the public schema
6069 * and assume a predetermined default, for several reasons. First,
6070 * dropping and recreating the schema removes its pg_init_privs entry,
6071 * but an empty destination database starts with this ACL nonetheless.
6072 * Second, we support dump/reload of public schema ownership changes.
6073 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
6074 * initprivs continues to reflect the initial owner. Hence,
6075 * synthesize the value that nspacl will have after the restore's
6076 * ALTER SCHEMA OWNER. Third, this makes the destination database
6077 * match the source's ACL, even if the latter was an initdb-default
6078 * ACL, which changed in v15. An upgrade pulls in changes to most
6079 * system object ACLs that the DBA had not customized. We've made the
6080 * public schema depart from that, because changing its ACL so easily
6081 * breaks applications.
6082 */
6084 {
6087
6088 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
6099
6103
6106 }
6107 }
6108
6109 PQclear(res);
6110 destroyPQExpBuffer(query);
6111}
6112
6113/*
6114 * findNamespace:
6115 * given a namespace OID, look up the info read by getNamespaces
6116 */
6119{
6121
6126}
6127
6128/*
6129 * getExtensions:
6130 * read all extensions in the system catalogs and return them in the
6131 * ExtensionInfo* structure
6132 *
6133 * numExtensions is set to the number of extensions read in
6134 */
6135ExtensionInfo *
6137{
6139 PGresult *res;
6140 int ntups;
6142 PQExpBuffer query;
6152
6153 query = createPQExpBuffer();
6154
6156 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
6157 "FROM pg_extension x "
6158 "JOIN pg_namespace n ON n.oid = x.extnamespace");
6159
6161
6162 ntups = PQntuples(res);
6163 if (ntups == 0)
6165
6167
6176
6178 {
6189
6190 /* Decide whether we want to dump it */
6192 }
6193
6194cleanup:
6195 PQclear(res);
6196 destroyPQExpBuffer(query);
6197
6198 *numExtensions = ntups;
6199
6201}
6202
6203/*
6204 * getTypes:
6205 * get information about all types in the system catalogs
6206 *
6207 * NB: this must run after getFuncs() because we assume we can do
6208 * findFuncByOid().
6209 */
6210void
6212{
6213 PGresult *res;
6214 int ntups;
6233
6234 /*
6235 * we include even the built-in types because those may be used as array
6236 * elements by user-defined types
6237 *
6238 * we filter out the built-in types when we dump out the types
6239 *
6240 * same approach for undefined (shell) types and array types
6241 *
6242 * Note: as of 8.3 we can reliably detect whether a type is an
6243 * auto-generated array type by checking the element type's typarray.
6244 * (Before that the test is capable of generating false positives.) We
6245 * still check for name beginning with '_', though, so as to avoid the
6246 * cost of the subselect probe for all standard types. This would have to
6247 * be revisited if the backend ever allows renaming of array types.
6248 */
6250 "typnamespace, typacl, "
6251 "acldefault('T', typowner) AS acldefault, "
6252 "typowner, "
6253 "typelem, typrelid, typarray, "
6254 "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
6255 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
6256 "typtype, typisdefined, "
6257 "typname[0] = '_' AND typelem != 0 AND "
6258 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
6259 "FROM pg_type");
6260
6262
6263 ntups = PQntuples(res);
6264
6266
6281
6283 {
6302
6305 else
6307
6310 else
6312
6314
6317 else
6319
6320 /* Decide whether we want to dump it */
6322
6323 /* Mark whether type has an ACL */
6326
6327 /*
6328 * If it's a domain, fetch info about its constraints, if any
6329 */
6336
6337 /*
6338 * If it's a base type, make a DumpableObject representing a shell
6339 * definition of the type. We will need to dump that ahead of the I/O
6340 * functions for the type. Similarly, range types need a shell
6341 * definition in case they have a canonicalize function.
6342 *
6343 * Note: the shell type doesn't have a catId. You might think it
6344 * should copy the base type's catId, but then it might capture the
6345 * pg_depend entries for the type, which we don't want.
6346 */
6350 {
6359
6360 /*
6361 * Initially mark the shell type as not to be dumped. We'll only
6362 * dump it if the I/O or canonicalize functions need to be dumped;
6363 * this is taken care of while sorting dependencies.
6364 */
6366 }
6367 }
6368
6369 PQclear(res);
6370
6371 destroyPQExpBuffer(query);
6372}
6373
6374/*
6375 * getOperators:
6376 * get information about all operators in the system catalogs
6377 */
6378void
6380{
6381 PGresult *res;
6382 int ntups;
6395
6396 /*
6397 * find all operators, including builtin operators; we filter out
6398 * system-defined operators at dump-out time.
6399 */
6400
6402 "oprnamespace, "
6403 "oprowner, "
6404 "oprkind, "
6405 "oprleft, "
6406 "oprright, "
6407 "oprcode::oid AS oprcode "
6408 "FROM pg_operator");
6409
6411
6412 ntups = PQntuples(res);
6413
6415
6425
6427 {
6440
6441 /* Decide whether we want to dump it */
6443 }
6444
6445 PQclear(res);
6446
6447 destroyPQExpBuffer(query);
6448}
6449
6450/*
6451 * getCollations:
6452 * get information about all collations in the system catalogs
6453 */
6454void
6456{
6457 PGresult *res;
6458 int ntups;
6460 PQExpBuffer query;
6468
6469 query = createPQExpBuffer();
6470
6471 /*
6472 * find all collations, including builtin collations; we filter out
6473 * system-defined collations at dump-out time.
6474 */
6475
6477 "collnamespace, "
6478 "collowner, "
6479 "collencoding "
6480 "FROM pg_collation");
6481
6483
6484 ntups = PQntuples(res);
6485
6487
6494
6496 {
6506
6507 /* Decide whether we want to dump it */
6509 }
6510
6511 PQclear(res);
6512
6513 destroyPQExpBuffer(query);
6514}
6515
6516/*
6517 * getConversions:
6518 * get information about all conversions in the system catalogs
6519 */
6520void
6522{
6523 PGresult *res;
6524 int ntups;
6526 PQExpBuffer query;
6533
6534 query = createPQExpBuffer();
6535
6536 /*
6537 * find all conversions, including builtin conversions; we filter out
6538 * system-defined conversions at dump-out time.
6539 */
6540
6542 "connamespace, "
6543 "conowner "
6544 "FROM pg_conversion");
6545
6547
6548 ntups = PQntuples(res);
6549
6551
6557
6559 {
6568
6569 /* Decide whether we want to dump it */
6571 }
6572
6573 PQclear(res);
6574
6575 destroyPQExpBuffer(query);
6576}
6577
6578/*
6579 * getAccessMethods:
6580 * get information about all user-defined access methods
6581 */
6582void
6584{
6585 PGresult *res;
6586 int ntups;
6588 PQExpBuffer query;
6595
6596 query = createPQExpBuffer();
6597
6598 /*
6599 * Select all access methods from pg_am table. v9.6 introduced CREATE
6600 * ACCESS METHOD, so earlier versions usually have only built-in access
6601 * methods. v9.6 also changed the access method API, replacing dozens of
6602 * pg_am columns with amhandler. Even if a user created an access method
6603 * by "INSERT INTO pg_am", we have no way to translate pre-v9.6 pg_am
6604 * columns to a v9.6+ CREATE ACCESS METHOD. Hence, before v9.6, read
6605 * pg_am just to facilitate findAccessMethodByOid() providing the
6606 * OID-to-name mapping.
6607 */
6610 appendPQExpBufferStr(query,
6611 "amtype, "
6612 "amhandler::pg_catalog.regproc AS amhandler ");
6613 else
6614 appendPQExpBufferStr(query,
6615 "'i'::pg_catalog.\"char\" AS amtype, "
6616 "'-'::pg_catalog.regproc AS amhandler ");
6618
6620
6621 ntups = PQntuples(res);
6622
6624
6630
6632 {
6641
6642 /* Decide whether we want to dump it */
6644 }
6645
6646 PQclear(res);
6647
6648 destroyPQExpBuffer(query);
6649}
6650
6651
6652/*
6653 * getOpclasses:
6654 * get information about all opclasses in the system catalogs
6655 */
6656void
6658{
6659 PGresult *res;
6660 int ntups;
6670
6671 /*
6672 * find all opclasses, including builtin opclasses; we filter out
6673 * system-defined opclasses at dump-out time.
6674 */
6675
6677 "opcnamespace, "
6678 "opcowner "
6679 "FROM pg_opclass");
6680
6682
6683 ntups = PQntuples(res);
6684
6686
6693
6695 {
6705
6706 /* Decide whether we want to dump it */
6708 }
6709
6710 PQclear(res);
6711
6712 destroyPQExpBuffer(query);
6713}
6714
6715/*
6716 * getOpfamilies:
6717 * get information about all opfamilies in the system catalogs
6718 */
6719void
6721{
6722 PGresult *res;
6723 int ntups;
6725 PQExpBuffer query;
6733
6734 query = createPQExpBuffer();
6735
6736 /*
6737 * find all opfamilies, including builtin opfamilies; we filter out
6738 * system-defined opfamilies at dump-out time.
6739 */
6740
6742 "opfnamespace, "
6743 "opfowner "
6744 "FROM pg_opfamily");
6745
6747
6748 ntups = PQntuples(res);
6749
6751
6758
6760 {
6770
6771 /* Decide whether we want to dump it */
6773 }
6774
6775 PQclear(res);
6776
6777 destroyPQExpBuffer(query);
6778}
6779
6780/*
6781 * getAggregates:
6782 * get information about all user-defined aggregates in the system catalogs
6783 */
6784void
6786{
6788 PGresult *res;
6789 int ntups;
6802
6803 /*
6804 * Find all interesting aggregates. See comment in getFuncs() for the
6805 * rationale behind the filtering logic.
6806 */
6808 {
6810
6812 : "p.proisagg");
6813
6815 "p.proname AS aggname, "
6816 "p.pronamespace AS aggnamespace, "
6817 "p.pronargs, p.proargtypes, "
6818 "p.proowner, "
6819 "p.proacl AS aggacl, "
6820 "acldefault('f', p.proowner) AS acldefault "
6821 "FROM pg_proc p "
6822 "LEFT JOIN pg_init_privs pip ON "
6823 "(p.oid = pip.objoid "
6824 "AND pip.classoid = 'pg_proc'::regclass "
6825 "AND pip.objsubid = 0) "
6826 "WHERE %s AND ("
6827 "p.pronamespace != "
6828 "(SELECT oid FROM pg_namespace "
6829 "WHERE nspname = 'pg_catalog') OR "
6830 "p.proacl IS DISTINCT FROM pip.initprivs",
6831 agg_check);
6833 appendPQExpBufferStr(query,
6834 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6835 "classid = 'pg_proc'::regclass AND "
6836 "objid = p.oid AND "
6837 "refclassid = 'pg_extension'::regclass AND "
6838 "deptype = 'e')");
6840 }
6841 else
6842 {
6844 "pronamespace AS aggnamespace, "
6845 "pronargs, proargtypes, "
6846 "proowner, "
6847 "proacl AS aggacl, "
6848 "acldefault('f', proowner) AS acldefault "
6849 "FROM pg_proc p "
6850 "WHERE proisagg AND ("
6851 "pronamespace != "
6852 "(SELECT oid FROM pg_namespace "
6853 "WHERE nspname = 'pg_catalog')");
6855 appendPQExpBufferStr(query,
6856 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6857 "classid = 'pg_proc'::regclass AND "
6858 "objid = p.oid AND "
6859 "refclassid = 'pg_extension'::regclass AND "
6860 "deptype = 'e')");
6862 }
6863
6865
6866 ntups = PQntuples(res);
6867
6869
6879
6881 {
6899 else
6900 {
6905 }
6907
6908 /* Decide whether we want to dump it */
6910
6911 /* Mark whether aggregate has an ACL */
6914 }
6915
6916 PQclear(res);
6917
6918 destroyPQExpBuffer(query);
6919}
6920
6921/*
6922 * getFuncs:
6923 * get information about all user-defined functions in the system catalogs
6924 */
6925void
6927{
6929 PGresult *res;
6930 int ntups;
6933 FuncInfo *finfo;
6945
6946 /*
6947 * Find all interesting functions. This is a bit complicated:
6948 *
6949 * 1. Always exclude aggregates; those are handled elsewhere.
6950 *
6951 * 2. Always exclude functions that are internally dependent on something
6952 * else, since presumably those will be created as a result of creating
6953 * the something else. This currently acts only to suppress constructor
6954 * functions for range types. Note this is OK only because the
6955 * constructors don't have any dependencies the range type doesn't have;
6956 * otherwise we might not get creation ordering correct.
6957 *
6958 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
6959 * they're members of extensions and we are in binary-upgrade mode then
6960 * include them, since we want to dump extension members individually in
6961 * that mode. Also, if they are used by casts or transforms then we need
6962 * to gather the information about them, though they won't be dumped if
6963 * they are built-in. Also, in 9.6 and up, include functions in
6964 * pg_catalog if they have an ACL different from what's shown in
6965 * pg_init_privs (so we have to join to pg_init_privs; annoying).
6966 */
6968 {
6970
6972 : "NOT p.proisagg");
6973
6974 appendPQExpBuffer(query,
6975 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
6976 "p.pronargs, p.proargtypes, p.prorettype, "
6977 "p.proacl, "
6978 "acldefault('f', p.proowner) AS acldefault, "
6979 "p.pronamespace, "
6980 "p.proowner "
6981 "FROM pg_proc p "
6982 "LEFT JOIN pg_init_privs pip ON "
6983 "(p.oid = pip.objoid "
6984 "AND pip.classoid = 'pg_proc'::regclass "
6985 "AND pip.objsubid = 0) "
6986 "WHERE %s"
6987 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
6988 "WHERE classid = 'pg_proc'::regclass AND "
6989 "objid = p.oid AND deptype = 'i')"
6990 "\n AND ("
6991 "\n pronamespace != "
6992 "(SELECT oid FROM pg_namespace "
6993 "WHERE nspname = 'pg_catalog')"
6994 "\n OR EXISTS (SELECT 1 FROM pg_cast"
6995 "\n WHERE pg_cast.oid > %u "
6996 "\n AND p.oid = pg_cast.castfunc)"
6997 "\n OR EXISTS (SELECT 1 FROM pg_transform"
6998 "\n WHERE pg_transform.oid > %u AND "
6999 "\n (p.oid = pg_transform.trffromsql"
7000 "\n OR p.oid = pg_transform.trftosql))",
7001 not_agg_check,
7002 g_last_builtin_oid,
7003 g_last_builtin_oid);
7005 appendPQExpBufferStr(query,
7006 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7007 "classid = 'pg_proc'::regclass AND "
7008 "objid = p.oid AND "
7009 "refclassid = 'pg_extension'::regclass AND "
7010 "deptype = 'e')");
7011 appendPQExpBufferStr(query,
7012 "\n OR p.proacl IS DISTINCT FROM pip.initprivs");
7014 }
7015 else
7016 {
7017 appendPQExpBuffer(query,
7018 "SELECT tableoid, oid, proname, prolang, "
7019 "pronargs, proargtypes, prorettype, proacl, "
7020 "acldefault('f', proowner) AS acldefault, "
7021 "pronamespace, "
7022 "proowner "
7023 "FROM pg_proc p "
7024 "WHERE NOT proisagg"
7025 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
7026 "WHERE classid = 'pg_proc'::regclass AND "
7027 "objid = p.oid AND deptype = 'i')"
7028 "\n AND ("
7029 "\n pronamespace != "
7030 "(SELECT oid FROM pg_namespace "
7031 "WHERE nspname = 'pg_catalog')"
7032 "\n OR EXISTS (SELECT 1 FROM pg_cast"
7033 "\n WHERE pg_cast.oid > '%u'::oid"
7034 "\n AND p.oid = pg_cast.castfunc)",
7035 g_last_builtin_oid);
7036
7038 appendPQExpBuffer(query,
7039 "\n OR EXISTS (SELECT 1 FROM pg_transform"
7040 "\n WHERE pg_transform.oid > '%u'::oid"
7041 "\n AND (p.oid = pg_transform.trffromsql"
7042 "\n OR p.oid = pg_transform.trftosql))",
7043 g_last_builtin_oid);
7044
7046 appendPQExpBufferStr(query,
7047 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7048 "classid = 'pg_proc'::regclass AND "
7049 "objid = p.oid AND "
7050 "refclassid = 'pg_extension'::regclass AND "
7051 "deptype = 'e')");
7053 }
7054
7056
7057 ntups = PQntuples(res);
7058
7060
7072
7074 {
7092 else
7093 {
7097 }
7099
7100 /* Decide whether we want to dump it */
7102
7103 /* Mark whether function has an ACL */
7106 }
7107
7108 PQclear(res);
7109
7110 destroyPQExpBuffer(query);
7111}
7112
7113/*
7114 * getRelationStatistics
7115 * register the statistics object as a dependent of the relation.
7116 *
7117 * reltuples is passed as a string to avoid complexities in converting from/to
7118 * floating point.
7119 */
7124 char **indAttNames, int nindAttNames)
7125{
7128
7130 (relkind == RELKIND_PARTITIONED_TABLE) ||
7131 (relkind == RELKIND_INDEX) ||
7132 (relkind == RELKIND_PARTITIONED_INDEX) ||
7133 (relkind == RELKIND_MATVIEW ||
7134 relkind == RELKIND_FOREIGN_TABLE))
7135 {
7138
7142 AssignDumpId(dobj);
7145 dobj->nDeps = 1;
7146 dobj->allocDeps = 1;
7149 dobj->namespace = rel->namespace;
7150 info->relpages = relpages;
7152 info->relallvisible = relallvisible;
7153 info->relallfrozen = relallfrozen;
7154 info->relkind = relkind;
7155 info->indAttNames = indAttNames;
7156 info->nindAttNames = nindAttNames;
7157
7158 /*
7159 * Ordinarily, stats go in SECTION_DATA for tables and
7160 * SECTION_POST_DATA for indexes.
7161 *
7162 * However, the section may be updated later for materialized view
7163 * stats. REFRESH MATERIALIZED VIEW replaces the storage and resets
7164 * the stats, so the stats must be restored after the data. Also, the
7165 * materialized view definition may be postponed to SECTION_POST_DATA
7166 * (see repairMatViewBoundaryMultiLoop()).
7167 */
7169 {
7175 break;
7179 break;
7180 default:
7182 info->relkind);
7183 }
7184
7185 return info;
7186 }
7188}
7189
7190/*
7191 * getTables
7192 * read all the tables (no indexes) in the system catalogs,
7193 * and return them as an array of TableInfo structures
7194 *
7195 * *numTables is set to the number of tables read in
7196 */
7197TableInfo *
7199{
7201 PGresult *res;
7202 int ntups;
7205 TableInfo *tblinfo;
7246
7247 /*
7248 * Find all the tables and table-like objects.
7249 *
7250 * We must fetch all tables in this phase because otherwise we cannot
7251 * correctly identify inherited columns, owned sequences, etc.
7252 *
7253 * We include system catalogs, so that we can work if a user table is
7254 * defined to inherit from a system catalog (pretty weird, but...)
7255 *
7256 * Note: in this phase we should collect only a minimal amount of
7257 * information about each table, basically just enough to decide if it is
7258 * interesting. In particular, since we do not yet have lock on any user
7259 * table, we MUST NOT invoke any server-side data collection functions
7260 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
7261 * wrong answers if any concurrent DDL is happening.
7262 */
7263
7264 appendPQExpBufferStr(query,
7265 "SELECT c.tableoid, c.oid, c.relname, "
7266 "c.relnamespace, c.relkind, c.reltype, "
7267 "c.relowner, "
7268 "c.relchecks, "
7269 "c.relhasindex, c.relhasrules, c.relpages, "
7270 "c.reltuples, c.relallvisible, ");
7271
7274 else
7276
7277 appendPQExpBufferStr(query,
7278 "c.relhastriggers, c.relpersistence, "
7279 "c.reloftype, "
7280 "c.relacl, "
7282 " THEN 's'::\"char\" ELSE 'r'::\"char\" END, c.relowner) AS acldefault, "
7284 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
7285 "ELSE 0 END AS foreignserver, "
7286 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
7287 "tc.oid AS toid, "
7288 "tc.relpages AS toastpages, "
7289 "tc.reloptions AS toast_reloptions, "
7290 "d.refobjid AS owning_tab, "
7291 "d.refobjsubid AS owning_col, "
7292 "tsp.spcname AS reltablespace, ");
7293
7295 appendPQExpBufferStr(query,
7296 "false AS relhasoids, ");
7297 else
7298 appendPQExpBufferStr(query,
7299 "c.relhasoids, ");
7300
7302 appendPQExpBufferStr(query,
7303 "c.relispopulated, ");
7304 else
7305 appendPQExpBufferStr(query,
7306 "'t' as relispopulated, ");
7307
7309 appendPQExpBufferStr(query,
7310 "c.relreplident, ");
7311 else
7312 appendPQExpBufferStr(query,
7313 "'d' AS relreplident, ");
7314
7316 appendPQExpBufferStr(query,
7317 "c.relrowsecurity, c.relforcerowsecurity, ");
7318 else
7319 appendPQExpBufferStr(query,
7320 "false AS relrowsecurity, "
7321 "false AS relforcerowsecurity, ");
7322
7324 appendPQExpBufferStr(query,
7325 "c.relminmxid, tc.relminmxid AS tminmxid, ");
7326 else
7327 appendPQExpBufferStr(query,
7328 "0 AS relminmxid, 0 AS tminmxid, ");
7329
7331 appendPQExpBufferStr(query,
7332 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
7333 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
7334 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
7335 else
7336 appendPQExpBufferStr(query,
7337 "c.reloptions, NULL AS checkoption, ");
7338
7340 appendPQExpBufferStr(query,
7341 "am.amname, ");
7342 else
7343 appendPQExpBufferStr(query,
7344 "NULL AS amname, ");
7345
7347 appendPQExpBufferStr(query,
7348 "(d.deptype = 'i') IS TRUE AS is_identity_sequence, ");
7349 else
7350 appendPQExpBufferStr(query,
7351 "false AS is_identity_sequence, ");
7352
7354 appendPQExpBufferStr(query,
7355 "c.relispartition AS ispartition ");
7356 else
7357 appendPQExpBufferStr(query,
7358 "false AS ispartition ");
7359
7360 /*
7361 * Left join to pg_depend to pick up dependency info linking sequences to
7362 * their owning column, if any (note this dependency is AUTO except for
7363 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
7364 * collect the spcname.
7365 */
7366 appendPQExpBufferStr(query,
7367 "\nFROM pg_class c\n"
7368 "LEFT JOIN pg_depend d ON "
7370 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
7371 "d.objsubid = 0 AND "
7372 "d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i'))\n"
7373 "LEFT JOIN pg_tablespace tsp ON (tsp.oid = c.reltablespace)\n");
7374
7375 /*
7376 * In 9.6 and up, left join to pg_am to pick up the amname.
7377 */
7379 appendPQExpBufferStr(query,
7380 "LEFT JOIN pg_am am ON (c.relam = am.oid)\n");
7381
7382 /*
7383 * We purposefully ignore toast OIDs for partitioned tables; the reason is
7384 * that versions 10 and 11 have them, but later versions do not, so
7385 * emitting them causes the upgrade to fail.
7386 */
7387 appendPQExpBufferStr(query,
7388 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
7391
7392 /*
7393 * Restrict to interesting relkinds (in particular, not indexes). Not all
7394 * relkinds are possible in older servers, but it's not worth the trouble
7395 * to emit a version-dependent list.
7396 *
7397 * Composite-type table entries won't be dumped as such, but we have to
7398 * make a DumpableObject for them so that we can track dependencies of the
7399 * composite type (pg_depend entries for columns of the composite type
7400 * link to the pg_class entry not the pg_type entry).
7401 */
7402 appendPQExpBufferStr(query,
7403 "WHERE c.relkind IN ("
7411 "ORDER BY c.oid");
7412
7414
7415 ntups = PQntuples(res);
7416
7417 *numTables = ntups;
7418
7419 /*
7420 * Extract data from result and lock dumpable tables. We do the locking
7421 * before anything else, to minimize the window wherein a table could
7422 * disappear under us.
7423 *
7424 * Note that we have to save info about all tables here, even when dumping
7425 * only one, because we don't yet know which tables might be inheritance
7426 * ancestors of the target table.
7427 */
7429
7470
7472 {
7473 /*
7474 * Arrange to fail instead of waiting forever for a table lock.
7475 *
7476 * NB: this coding assumes that the only queries issued within the
7477 * following loop are LOCK TABLEs; else the timeout may be undesirably
7478 * applied to other things too.
7479 */
7480 resetPQExpBuffer(query);
7484 }
7485
7486 resetPQExpBuffer(query);
7487
7489 {
7492
7513 else
7516 {
7519 }
7520 else
7521 {
7524 }
7541 else
7548 else
7550 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
7552
7553 /* other fields were zeroed above */
7554
7555 /*
7556 * Decide whether we want to dump this table.
7557 */
7560 else
7562
7563 /*
7564 * Now, consider the table "interesting" if we need to dump its
7565 * definition, data or its statistics. Later on, we'll skip a lot of
7566 * data collection for uninteresting tables.
7567 *
7568 * Note: the "interesting" flag will also be set by flagInhTables for
7569 * parents of interesting tables, so that we collect necessary
7570 * inheritance info even when the parents are not themselves being
7571 * dumped. This is the main reason why we need an "interesting" flag
7572 * that's separate from the components-to-dump bitmask.
7573 */
7575 (DUMP_COMPONENT_DEFINITION |
7576 DUMP_COMPONENT_DATA |
7577 DUMP_COMPONENT_STATISTICS)) != 0;
7578
7581
7582 /* Tables have data */
7584
7585 /* Mark whether table has an ACL */
7589
7590 /* Add statistics */
7592 {
7593 RelStatsInfo *stats;
7594
7596 tblinfo[i].relpages,
7598 relallvisible, relallfrozen,
7602 }
7603
7604 /*
7605 * Read-lock target tables to make sure they aren't DROPPED or altered
7606 * in schema before we get around to dumping them.
7607 *
7608 * Note that we don't explicitly lock parents of the target tables; we
7609 * assume our lock on the child is enough to prevent schema
7610 * alterations to parent tables.
7611 *
7612 * NOTE: it'd be kinda nice to lock other relations too, not only
7613 * plain or partitioned tables, but the backend doesn't presently
7614 * allow that.
7615 *
7616 * We only need to lock the table for certain components; see
7617 * pg_dump.h
7618 */
7622 {
7623 /*
7624 * Tables are locked in batches. When dumping from a remote
7625 * server this can save a significant amount of time by reducing
7626 * the number of round trips.
7627 */
7631 else
7632 {
7635
7636 /* Arbitrarily end a batch when query length reaches 100K. */
7638 {
7639 /* Lock another batch of tables. */
7642 resetPQExpBuffer(query);
7643 }
7644 }
7645 }
7646 }
7647
7649 {
7650 /* Lock the tables in the last batch. */
7653 }
7654
7656 {
7658 }
7659
7660 PQclear(res);
7661
7662 destroyPQExpBuffer(query);
7663
7664 return tblinfo;
7665}
7666
7667/*
7668 * getOwnedSeqs
7669 * identify owned sequences and mark them as dumpable if owning table is
7670 *
7671 * We used to do this in getTables(), but it's better to do it after the
7672 * index used by findTableByOid() has been set up.
7673 */
7674void
7676{
7678
7679 /*
7680 * Force sequences that are "owned" by table columns to be dumped whenever
7681 * their owning table is being dumped.
7682 */
7684 {
7686 TableInfo *owning_tab;
7687
7689 continue; /* not an owned sequence */
7690
7695
7696 /*
7697 * For an identity sequence, dump exactly the same components for the
7698 * sequence as for the owning table. This is important because we
7699 * treat the identity sequence as an integral part of the table. For
7700 * example, there is not any DDL command that allows creation of such
7701 * a sequence independently of the table.
7702 *
7703 * For other owned sequences such as serial sequences, we need to dump
7704 * the components that are being dumped for the table and any
7705 * components that the sequence is explicitly marked with.
7706 *
7707 * We can't simply use the set of components which are being dumped
7708 * for the table as the table might be in an extension (and only the
7709 * non-extension components, eg: ACLs if changed, security labels, and
7710 * policies, are being dumped) while the sequence is not (and
7711 * therefore the definition and other components should also be
7712 * dumped).
7713 *
7714 * If the sequence is part of the extension then it should be properly
7715 * marked by checkExtensionMembership() and this will be a no-op as
7716 * the table will be equivalently marked.
7717 */
7720 else
7722
7723 /* Make sure that necessary data is available if we're dumping it */
7725 {
7728 }
7729 }
7730}
7731
7732/*
7733 * getInherits
7734 * read all the inheritance information
7735 * from the system catalogs return them in the InhInfo* structure
7736 *
7737 * numInherits is set to the number of pairs read in
7738 */
7739InhInfo *
7741{
7742 PGresult *res;
7743 int ntups;
7747
7750
7751 /* find all the inheritance information */
7753
7755
7756 ntups = PQntuples(res);
7757
7758 *numInherits = ntups;
7759
7761
7764
7766 {
7769 }
7770
7771 PQclear(res);
7772
7773 destroyPQExpBuffer(query);
7774
7776}
7777
7778/*
7779 * getPartitioningInfo
7780 * get information about partitioning
7781 *
7782 * For the most part, we only collect partitioning info about tables we
7783 * intend to dump. However, this function has to consider all partitioned
7784 * tables in the database, because we need to know about parents of partitions
7785 * we are going to dump even if the parents themselves won't be dumped.
7786 *
7787 * Specifically, what we need to know is whether each partitioned table
7788 * has an "unsafe" partitioning scheme that requires us to force
7789 * load-via-partition-root mode for its children. Currently the only case
7790 * for which we force that is hash partitioning on enum columns, since the
7791 * hash codes depend on enum value OIDs which won't be replicated across
7792 * dump-and-reload. There are other cases in which load-via-partition-root
7793 * might be necessary, but we expect users to cope with them.
7794 */
7795void
7797{
7798 PQExpBuffer query;
7799 PGresult *res;
7800 int ntups;
7801
7802 /* hash partitioning didn't exist before v11 */
7804 return;
7805 /* needn't bother if not dumping data */
7807 return;
7808
7809 query = createPQExpBuffer();
7810
7811 /*
7812 * Unsafe partitioning schemes are exactly those for which hash enum_ops
7813 * appears among the partition opclasses. We needn't check partstrat.
7814 *
7815 * Note that this query may well retrieve info about tables we aren't
7816 * going to dump and hence have no lock on. That's okay since we need not
7817 * invoke any unsafe server-side functions.
7818 */
7819 appendPQExpBufferStr(query,
7820 "SELECT partrelid FROM pg_partitioned_table WHERE\n"
7821 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7822 "ON c.opcmethod = a.oid\n"
7823 "WHERE opcname = 'enum_ops' "
7824 "AND opcnamespace = 'pg_catalog'::regnamespace "
7825 "AND amname = 'hash') = ANY(partclass)");
7826
7828
7829 ntups = PQntuples(res);
7830
7832 {
7835
7839 tabrelid);
7841 }
7842
7843 PQclear(res);
7844
7845 destroyPQExpBuffer(query);
7846}
7847
7848/*
7849 * getIndexes
7850 * get information about every index on a dumpable table
7851 *
7852 * Note: index data is not returned directly to the caller, but it
7853 * does get entered into the DumpableObject tables.
7854 */
7855void
7857{
7860 PGresult *res;
7861 int ntups;
7865 i_oid,
7866 i_indrelid,
7867 i_indexname,
7868 i_relpages,
7869 i_reltuples,
7870 i_relallvisible,
7871 i_relallfrozen,
7872 i_parentidx,
7873 i_indexdef,
7874 i_indnkeyatts,
7875 i_indnatts,
7876 i_indkey,
7877 i_indisclustered,
7878 i_indisreplident,
7879 i_indnullsnotdistinct,
7880 i_contype,
7881 i_conname,
7882 i_condeferrable,
7883 i_condeferred,
7884 i_conperiod,
7885 i_contableoid,
7886 i_conoid,
7887 i_condef,
7888 i_indattnames,
7889 i_tablespace,
7890 i_indreloptions,
7891 i_indstatcols,
7892 i_indstatvals;
7893
7894 /*
7895 * We want to perform just one query against pg_index. However, we
7896 * mustn't try to select every row of the catalog and then sort it out on
7897 * the client side, because some of the server-side functions we need
7898 * would be unsafe to apply to tables we don't have lock on. Hence, we
7899 * build an array of the OIDs of tables we care about (and now have lock
7900 * on!), and use a WHERE clause to constrain which rows are selected.
7901 */
7904 {
7906
7908 continue;
7909
7910 /*
7911 * We can ignore indexes of uninteresting tables.
7912 */
7914 continue;
7915
7916 /* OK, we need info for this table */
7920 }
7922
7923 appendPQExpBufferStr(query,
7924 "SELECT t.tableoid, t.oid, i.indrelid, "
7925 "t.relname AS indexname, "
7926 "t.relpages, t.reltuples, t.relallvisible, ");
7927
7930 else
7932
7933 appendPQExpBufferStr(query,
7934 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7935 "i.indkey, i.indisclustered, "
7936 "c.contype, c.conname, "
7937 "c.condeferrable, c.condeferred, "
7938 "c.tableoid AS contableoid, "
7939 "c.oid AS conoid, "
7940 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7941 "CASE WHEN i.indexprs IS NOT NULL THEN "
7942 "(SELECT pg_catalog.array_agg(attname ORDER BY attnum)"
7943 " FROM pg_catalog.pg_attribute "
7944 " WHERE attrelid = i.indexrelid) "
7945 "ELSE NULL END AS indattnames, "
7946 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7947 "t.reloptions AS indreloptions, ");
7948
7949
7951 appendPQExpBufferStr(query,
7952 "i.indisreplident, ");
7953 else
7954 appendPQExpBufferStr(query,
7955 "false AS indisreplident, ");
7956
7958 appendPQExpBufferStr(query,
7959 "inh.inhparent AS parentidx, "
7960 "i.indnkeyatts AS indnkeyatts, "
7961 "i.indnatts AS indnatts, "
7962 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7963 " FROM pg_catalog.pg_attribute "
7964 " WHERE attrelid = i.indexrelid AND "
7965 " attstattarget >= 0) AS indstatcols, "
7966 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7967 " FROM pg_catalog.pg_attribute "
7968 " WHERE attrelid = i.indexrelid AND "
7969 " attstattarget >= 0) AS indstatvals, ");
7970 else
7971 appendPQExpBufferStr(query,
7972 "0 AS parentidx, "
7973 "i.indnatts AS indnkeyatts, "
7974 "i.indnatts AS indnatts, "
7975 "'' AS indstatcols, "
7976 "'' AS indstatvals, ");
7977
7979 appendPQExpBufferStr(query,
7980 "i.indnullsnotdistinct, ");
7981 else
7982 appendPQExpBufferStr(query,
7983 "false AS indnullsnotdistinct, ");
7984
7986 appendPQExpBufferStr(query,
7987 "c.conperiod ");
7988 else
7989 appendPQExpBufferStr(query,
7990 "NULL AS conperiod ");
7991
7992 /*
7993 * The point of the messy-looking outer join is to find a constraint that
7994 * is related by an internal dependency link to the index. If we find one,
7995 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
7996 * index won't have more than one internal dependency.
7997 *
7998 * Note: the check on conrelid is redundant, but useful because that
7999 * column is indexed while conindid is not.
8000 */
8002 {
8003 appendPQExpBuffer(query,
8004 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8005 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8006 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8007 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
8008 "LEFT JOIN pg_catalog.pg_constraint c "
8009 "ON (i.indrelid = c.conrelid AND "
8010 "i.indexrelid = c.conindid AND "
8011 "c.contype IN ('p','u','x')) "
8012 "LEFT JOIN pg_catalog.pg_inherits inh "
8013 "ON (inh.inhrelid = indexrelid) "
8014 "WHERE (i.indisvalid OR t2.relkind = 'p') "
8015 "AND i.indisready "
8016 "ORDER BY i.indrelid, indexname",
8017 tbloids->data);
8018 }
8019 else
8020 {
8021 /*
8022 * the test on indisready is necessary in 9.2, and harmless in
8023 * earlier/later versions
8024 */
8025 appendPQExpBuffer(query,
8026 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8027 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8028 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8029 "LEFT JOIN pg_catalog.pg_constraint c "
8030 "ON (i.indrelid = c.conrelid AND "
8031 "i.indexrelid = c.conindid AND "
8032 "c.contype IN ('p','u','x')) "
8033 "WHERE i.indisvalid AND i.indisready "
8034 "ORDER BY i.indrelid, indexname",
8035 tbloids->data);
8036 }
8037
8039
8040 ntups = PQntuples(res);
8041
8071
8073
8074 /*
8075 * Outer loop iterates once per table, not once per row. Incrementing of
8076 * j is handled by the inner loop.
8077 */
8078 curtblindx = -1;
8080 {
8084 int nindAttNames = 0;
8086
8087 /* Count rows for this table */
8090 break;
8091
8092 /*
8093 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8094 * order.
8095 */
8097 {
8100 break;
8101 }
8104 /* cross-check that we only got requested tables */
8106 !tbinfo->interesting)
8108 tbinfo->dobj.name);
8109
8110 /* Save data for this table */
8113
8115 {
8116 char contype;
8122
8146 {
8148 };
8149
8152 else
8154
8156 {
8158 &indAttNames, &nindAttNames))
8160 }
8161
8164 relallvisible, relallfrozen, indexkind,
8165 indAttNames, nindAttNames);
8166
8168 if (contype == 'p' || contype == 'u' || contype == 'x')
8169 {
8170 /*
8171 * If we found a constraint matching the index, create an
8172 * entry for it.
8173 */
8175
8186 constrinfo->contype = contype;
8187 if (contype == 'x')
8189 else
8198
8202 }
8203 else
8204 {
8205 /* Plain secondary index */
8207 }
8208 }
8209 }
8210
8211 PQclear(res);
8212
8213 destroyPQExpBuffer(query);
8215}
8216
8217/*
8218 * getExtendedStatistics
8219 * get information about extended-statistics objects.
8220 *
8221 * Note: extended statistics data is not returned directly to the caller, but
8222 * it does get entered into the DumpableObject tables.
8223 */
8224void
8226{
8227 PQExpBuffer query;
8228 PGresult *res;
8230 int ntups;
8239
8240 /* Extended statistics were new in v10 */
8242 return;
8243
8244 query = createPQExpBuffer();
8245
8248 "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
8249 "FROM pg_catalog.pg_statistic_ext");
8250 else
8252 "stxnamespace, stxowner, stxrelid, stxstattarget "
8253 "FROM pg_catalog.pg_statistic_ext");
8254
8256
8257 ntups = PQntuples(res);
8258
8266
8268
8270 {
8283 else
8285
8286 /* Decide whether we want to dump it */
8288
8291 }
8292
8293 PQclear(res);
8294 destroyPQExpBuffer(query);
8295}
8296
8297/*
8298 * getConstraints
8299 *
8300 * Get info about constraints on dumpable tables.
8301 *
8302 * Currently handles foreign keys only.
8303 * Unique and primary key constraints are handled with indexes,
8304 * while check constraints are processed in getTableAttrs().
8305 */
8306void
8308{
8311 PGresult *res;
8312 int ntups;
8317 i_conoid,
8318 i_conrelid,
8319 i_conname,
8320 i_confrelid,
8321 i_conindid,
8322 i_condef;
8323
8324 /*
8325 * We want to perform just one query against pg_constraint. However, we
8326 * mustn't try to select every row of the catalog and then sort it out on
8327 * the client side, because some of the server-side functions we need
8328 * would be unsafe to apply to tables we don't have lock on. Hence, we
8329 * build an array of the OIDs of tables we care about (and now have lock
8330 * on!), and use a WHERE clause to constrain which rows are selected.
8331 */
8334 {
8336
8338 continue;
8339
8340 /* OK, we need info for this table */
8344 }
8346
8347 appendPQExpBufferStr(query,
8348 "SELECT c.tableoid, c.oid, "
8349 "conrelid, conname, confrelid, ");
8352 else
8354 appendPQExpBuffer(query,
8355 "pg_catalog.pg_get_constraintdef(c.oid) AS condef\n"
8356 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8357 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
8358 "WHERE contype = 'f' ",
8359 tbloids->data);
8361 appendPQExpBufferStr(query,
8362 "AND conparentid = 0 ");
8363 appendPQExpBufferStr(query,
8364 "ORDER BY conrelid, conname");
8365
8367
8368 ntups = PQntuples(res);
8369
8377
8379
8380 curtblindx = -1;
8382 {
8385
8386 /*
8387 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8388 * order.
8389 */
8391 {
8393 {
8396 break;
8397 }
8400 }
8401
8418
8419 /*
8420 * Restoring an FK that points to a partitioned table requires that
8421 * all partition indexes have been attached beforehand. Ensure that
8422 * happens by making the constraint depend on each index partition
8423 * attach object.
8424 */
8427 {
8429
8431 {
8433 {
8435
8436 /* not our index? */
8438 continue;
8439
8442 break;
8443 }
8444 }
8445 }
8446 }
8447
8448 PQclear(res);
8449
8450 destroyPQExpBuffer(query);
8452}
8453
8454/*
8455 * addConstrChildIdxDeps
8456 *
8457 * Recursive subroutine for getConstraints
8458 *
8459 * Given an object representing a foreign key constraint and an index on the
8460 * partitioned table it references, mark the constraint object as dependent
8461 * on the DO_INDEX_ATTACH object of each index partition, recursively
8462 * drilling down to their partitions if any. This ensures that the FK is not
8463 * restored until the index is fully marked valid.
8464 */
8465static void
8467{
8468 SimplePtrListCell *cell;
8469
8471
8473 {
8475
8477
8480 }
8481}
8482
8483/*
8484 * getDomainConstraints
8485 *
8486 * Get info about constraints on a domain.
8487 */
8488static void
8490{
8493 PGresult *res;
8495 i_oid,
8496 i_conname,
8497 i_consrc,
8498 i_convalidated,
8499 i_contype;
8500 int ntups;
8501
8503 {
8504 /*
8505 * Set up query for constraint-specific details. For servers 17 and
8506 * up, domains have constraints of type 'n' as well as 'c', otherwise
8507 * just the latter.
8508 */
8509 appendPQExpBuffer(query,
8510 "PREPARE getDomainConstraints(pg_catalog.oid) AS\n"
8511 "SELECT tableoid, oid, conname, "
8512 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8513 "convalidated, contype "
8514 "FROM pg_catalog.pg_constraint "
8515 "WHERE contypid = $1 AND contype IN (%s) "
8516 "ORDER BY conname",
8518
8520
8522 }
8523
8524 printfPQExpBuffer(query,
8525 "EXECUTE getDomainConstraints('%u')",
8526 tyinfo->dobj.catId.oid);
8527
8529
8530 ntups = PQntuples(res);
8531
8538
8541
8542 /* 'i' tracks result rows; 'j' counts CHECK constraints */
8544 {
8547 ConstraintInfo *constraint;
8548
8550 {
8552 tyinfo->nDomChecks++;
8553 }
8554 else
8555 {
8558 /* use last item in array for the not-null constraint */
8560 constraint = tyinfo->notnull;
8561 }
8562
8571 constraint->contype = contype;
8574 constraint->conindex = 0;
8578
8580
8581 /*
8582 * Make the domain depend on the constraint, ensuring it won't be
8583 * output till any constraint dependencies are OK. If the constraint
8584 * has not been validated, it's going to be dumped after the domain
8585 * anyway, so this doesn't matter.
8586 */
8589 }
8590
8591 PQclear(res);
8592
8593 destroyPQExpBuffer(query);
8594}
8595
8596/*
8597 * getRules
8598 * get basic information about every rule in the system
8599 */
8600void
8602{
8603 PGresult *res;
8604 int ntups;
8615
8617 "tableoid, oid, rulename, "
8618 "ev_class AS ruletable, ev_type, is_instead, "
8619 "ev_enabled "
8620 "FROM pg_rewrite "
8621 "ORDER BY oid");
8622
8624
8625 ntups = PQntuples(res);
8626
8628
8636
8638 {
8640
8649 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
8657 {
8658 /*
8659 * If the table is a view or materialized view, force its ON
8660 * SELECT rule to be sorted before the view itself --- this
8661 * ensures that any dependencies for the rule affect the table's
8662 * positioning. Other rules are forced to appear after their
8663 * table.
8664 */
8668 {
8671 /* We'll merge the rule into CREATE VIEW, if possible */
8673 }
8674 else
8675 {
8679 }
8680 }
8681 else
8683 }
8684
8685 PQclear(res);
8686
8687 destroyPQExpBuffer(query);
8688}
8689
8690/*
8691 * getTriggers
8692 * get information about every trigger on a dumpable table
8693 *
8694 * Note: trigger data is not returned directly to the caller, but it
8695 * does get entered into the DumpableObject tables.
8696 */
8697void
8699{
8702 PGresult *res;
8703 int ntups;
8707 i_oid,
8708 i_tgrelid,
8709 i_tgname,
8710 i_tgenabled,
8711 i_tgispartition,
8712 i_tgdef;
8713
8714 /*
8715 * We want to perform just one query against pg_trigger. However, we
8716 * mustn't try to select every row of the catalog and then sort it out on
8717 * the client side, because some of the server-side functions we need
8718 * would be unsafe to apply to tables we don't have lock on. Hence, we
8719 * build an array of the OIDs of tables we care about (and now have lock
8720 * on!), and use a WHERE clause to constrain which rows are selected.
8721 */
8724 {
8726
8729 continue;
8730
8731 /* OK, we need info for this table */
8735 }
8737
8739 {
8740 /*
8741 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8742 * result in non-forward-compatible dumps of WHEN clauses due to
8743 * under-parenthesization.
8744 *
8745 * NB: We need to see partition triggers in case the tgenabled flag
8746 * has been changed from the parent.
8747 */
8748 appendPQExpBuffer(query,
8749 "SELECT t.tgrelid, t.tgname, "
8750 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8751 "t.tgenabled, t.tableoid, t.oid, "
8752 "t.tgparentid <> 0 AS tgispartition\n"
8753 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8754 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8755 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8756 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
8757 "OR t.tgenabled != u.tgenabled) "
8758 "ORDER BY t.tgrelid, t.tgname",
8759 tbloids->data);
8760 }
8762 {
8763 /*
8764 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8765 * result in non-forward-compatible dumps of WHEN clauses due to
8766 * under-parenthesization.
8767 *
8768 * NB: We need to see tgisinternal triggers in partitions, in case the
8769 * tgenabled flag has been changed from the parent.
8770 */
8771 appendPQExpBuffer(query,
8772 "SELECT t.tgrelid, t.tgname, "
8773 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8774 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition\n"
8775 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8776 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8777 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8778 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
8779 "ORDER BY t.tgrelid, t.tgname",
8780 tbloids->data);
8781 }
8783 {
8784 /*
8785 * NB: We need to see tgisinternal triggers in partitions, in case the
8786 * tgenabled flag has been changed from the parent. No tgparentid in
8787 * version 11-12, so we have to match them via pg_depend.
8788 *
8789 * See above about pretty=true in pg_get_triggerdef.
8790 */
8791 appendPQExpBuffer(query,
8792 "SELECT t.tgrelid, t.tgname, "
8793 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8794 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
8795 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8796 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8797 "LEFT JOIN pg_catalog.pg_depend AS d ON "
8798 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8799 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8800 " d.objid = t.oid "
8801 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
8802 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
8803 "ORDER BY t.tgrelid, t.tgname",
8804 tbloids->data);
8805 }
8806 else
8807 {
8808 /* See above about pretty=true in pg_get_triggerdef */
8809 appendPQExpBuffer(query,
8810 "SELECT t.tgrelid, t.tgname, "
8811 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8812 "t.tgenabled, false as tgispartition, "
8813 "t.tableoid, t.oid "
8814 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8815 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8816 "WHERE NOT tgisinternal "
8817 "ORDER BY t.tgrelid, t.tgname",
8818 tbloids->data);
8819 }
8820
8822
8823 ntups = PQntuples(res);
8824
8832
8834
8835 /*
8836 * Outer loop iterates once per table, not once per row. Incrementing of
8837 * j is handled by the inner loop.
8838 */
8839 curtblindx = -1;
8841 {
8845
8846 /* Count rows for this table */
8849 break;
8850
8851 /*
8852 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8853 * order.
8854 */
8856 {
8859 break;
8860 }
8863
8864 /* Save data for this table */
8867
8869 {
8880 }
8881 }
8882
8883 PQclear(res);
8884
8885 destroyPQExpBuffer(query);
8887}
8888
8889/*
8890 * getEventTriggers
8891 * get information about event triggers
8892 */
8893void
8895{
8897 PQExpBuffer query;
8898 PGresult *res;
8901 i_oid,
8902 i_evtname,
8903 i_evtevent,
8904 i_evtowner,
8905 i_evttags,
8906 i_evtfname,
8907 i_evtenabled;
8908 int ntups;
8909
8910 /* Before 9.3, there are no event triggers */
8912 return;
8913
8914 query = createPQExpBuffer();
8915
8916 appendPQExpBufferStr(query,
8917 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8918 "evtevent, evtowner, "
8919 "array_to_string(array("
8920 "select quote_literal(x) "
8921 " from unnest(evttags) as t(x)), ', ') as evttags, "
8922 "e.evtfoid::regproc as evtfname "
8923 "FROM pg_event_trigger e "
8924 "ORDER BY e.oid");
8925
8927
8928 ntups = PQntuples(res);
8929
8931
8940
8942 {
8954
8955 /* Decide whether we want to dump it */
8957 }
8958
8959 PQclear(res);
8960
8961 destroyPQExpBuffer(query);
8962}
8963
8964/*
8965 * getProcLangs
8966 * get basic information about every procedural language in the system
8967 *
8968 * NB: this must run after getFuncs() because we assume we can do
8969 * findFuncByOid().
8970 */
8971void
8973{
8974 PGresult *res;
8975 int ntups;
8989
8991 "lanname, lanpltrusted, lanplcallfoid, "
8992 "laninline, lanvalidator, "
8993 "lanacl, "
8994 "acldefault('l', lanowner) AS acldefault, "
8995 "lanowner "
8996 "FROM pg_language "
8997 "WHERE lanispl "
8998 "ORDER BY oid");
8999
9001
9002 ntups = PQntuples(res);
9003
9005
9016
9018 {
9023
9034
9035 /* Decide whether we want to dump it */
9037
9038 /* Mark whether language has an ACL */
9041 }
9042
9043 PQclear(res);
9044
9045 destroyPQExpBuffer(query);
9046}
9047
9048/*
9049 * getCasts
9050 * get basic information about most casts in the system
9051 *
9052 * Skip casts from a range to its multirange, since we'll create those
9053 * automatically.
9054 */
9055void
9057{
9058 PGresult *res;
9059 int ntups;
9070
9072 {
9074 "castsource, casttarget, castfunc, castcontext, "
9075 "castmethod "
9076 "FROM pg_cast c "
9077 "WHERE NOT EXISTS ( "
9078 "SELECT 1 FROM pg_range r "
9079 "WHERE c.castsource = r.rngtypid "
9080 "AND c.casttarget = r.rngmultitypid "
9081 ") "
9082 "ORDER BY 3,4");
9083 }
9084 else
9085 {
9087 "castsource, casttarget, castfunc, castcontext, "
9088 "castmethod "
9089 "FROM pg_cast ORDER BY 3,4");
9090 }
9091
9093
9094 ntups = PQntuples(res);
9095
9097
9105
9107 {
9111
9121
9122 /*
9123 * Try to name cast as concatenation of typnames. This is only used
9124 * for purposes of sorting. If we fail to find either type, the name
9125 * will be an empty string.
9126 */
9134
9135 /* Decide whether we want to dump it */
9137 }
9138
9139 PQclear(res);
9140
9141 destroyPQExpBuffer(query);
9142}
9143
9144static char *
9146{
9147 PQExpBuffer query;
9148 PGresult *res;
9150
9151 query = createPQExpBuffer();
9155 destroyPQExpBuffer(query);
9156 PQclear(res);
9157
9159}
9160
9161/*
9162 * getTransforms
9163 * get basic information about every transform in the system
9164 */
9165void
9167{
9168 PGresult *res;
9169 int ntups;
9171 PQExpBuffer query;
9179
9180 /* Transforms didn't exist pre-9.5 */
9182 return;
9183
9184 query = createPQExpBuffer();
9185
9187 "trftype, trflang, trffromsql::oid, trftosql::oid "
9188 "FROM pg_transform "
9189 "ORDER BY 3,4");
9190
9192
9193 ntups = PQntuples(res);
9194
9196
9203
9205 {
9209
9218
9219 /*
9220 * Try to name transform as concatenation of type and language name.
9221 * This is only used for purposes of sorting. If we fail to find
9222 * either, the name will be an empty string.
9223 */
9232
9233 /* Decide whether we want to dump it */
9235 }
9236
9237 PQclear(res);
9238
9239 destroyPQExpBuffer(query);
9240}
9241
9242/*
9243 * getTableAttrs -
9244 * for each interesting table, read info about its attributes
9245 * (names, types, default values, CHECK constraints, etc)
9246 *
9247 * modifies tblinfo
9248 */
9249void
9251{
9257 PGresult *res;
9258 int ntups;
9284
9285 /*
9286 * We want to perform just one query against pg_attribute, and then just
9287 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
9288 * (for CHECK constraints and for NOT NULL constraints). However, we
9289 * mustn't try to select every row of those catalogs and then sort it out
9290 * on the client side, because some of the server-side functions we need
9291 * would be unsafe to apply to tables we don't have lock on. Hence, we
9292 * build an array of the OIDs of tables we care about (and now have lock
9293 * on!), and use a WHERE clause to constrain which rows are selected.
9294 */
9298 {
9300
9301 /* Don't bother to collect info for sequences */
9303 continue;
9304
9305 /*
9306 * Don't bother with uninteresting tables, either. For binary
9307 * upgrades, this is bypassed for pg_largeobject_metadata and
9308 * pg_shdepend so that the columns names are collected for the
9309 * corresponding COPY commands. Restoring the data for those catalogs
9310 * is faster than restoring the equivalent set of large object
9311 * commands. We can only do this for upgrades from v12 and newer; in
9312 * older versions, pg_largeobject_metadata was created WITH OIDS, so
9313 * the OID column is hidden and won't be dumped.
9314 */
9319 continue;
9320
9321 /* OK, we need info for this table */
9325
9327 {
9328 /* Also make a list of the ones with check constraints */
9332 }
9333 }
9336
9337 /*
9338 * Find all the user attributes and their types.
9339 *
9340 * Since we only want to dump COLLATE clauses for attributes whose
9341 * collation is different from their type's default, we use a CASE here to
9342 * suppress uninteresting attcollations cheaply.
9343 */
9344 appendPQExpBufferStr(q,
9345 "SELECT\n"
9346 "a.attrelid,\n"
9347 "a.attnum,\n"
9348 "a.attname,\n"
9349 "a.attstattarget,\n"
9350 "a.attstorage,\n"
9351 "t.typstorage,\n"
9352 "a.atthasdef,\n"
9353 "a.attisdropped,\n"
9354 "a.attlen,\n"
9355 "a.attalign,\n"
9356 "a.attislocal,\n"
9357 "pg_catalog.format_type(t.oid, a.atttypmod) AS atttypname,\n"
9358 "array_to_string(a.attoptions, ', ') AS attoptions,\n"
9359 "CASE WHEN a.attcollation <> t.typcollation "
9360 "THEN a.attcollation ELSE 0 END AS attcollation,\n"
9361 "pg_catalog.array_to_string(ARRAY("
9362 "SELECT pg_catalog.quote_ident(option_name) || "
9363 "' ' || pg_catalog.quote_literal(option_value) "
9364 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
9365 "ORDER BY option_name"
9366 "), E',\n ') AS attfdwoptions,\n");
9367
9368 /*
9369 * Find out any NOT NULL markings for each column. In 18 and up we read
9370 * pg_constraint to obtain the constraint name, and for valid constraints
9371 * also pg_description to obtain its comment. notnull_noinherit is set
9372 * according to the NO INHERIT property. For versions prior to 18, we
9373 * store an empty string as the name when a constraint is marked as
9374 * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
9375 * without a name); also, such cases are never NO INHERIT.
9376 *
9377 * For invalid constraints, we need to store their OIDs for processing
9378 * elsewhere, so we bring the pg_constraint.oid value when the constraint
9379 * is invalid, and NULL otherwise. Their comments are handled not here
9380 * but by collectComments, because they're their own dumpable object.
9381 *
9382 * We track in notnull_islocal whether the constraint was defined directly
9383 * in this table or via an ancestor, for binary upgrade. flagInhAttrs
9384 * might modify this later.
9385 */
9387 appendPQExpBufferStr(q,
9388 "co.conname AS notnull_name,\n"
9389 "CASE WHEN co.convalidated THEN pt.description"
9390 " ELSE NULL END AS notnull_comment,\n"
9391 "CASE WHEN NOT co.convalidated THEN co.oid "
9392 "ELSE NULL END AS notnull_invalidoid,\n"
9393 "co.connoinherit AS notnull_noinherit,\n"
9394 "co.conislocal AS notnull_islocal,\n");
9395 else
9396 appendPQExpBufferStr(q,
9397 "CASE WHEN a.attnotnull THEN '' ELSE NULL END AS notnull_name,\n"
9398 "NULL AS notnull_comment,\n"
9399 "NULL AS notnull_invalidoid,\n"
9400 "false AS notnull_noinherit,\n"
9401 "CASE WHEN a.attislocal THEN true\n"
9402 " WHEN a.attnotnull AND NOT a.attislocal THEN true\n"
9403 " ELSE false\n"
9404 "END AS notnull_islocal,\n");
9405
9407 appendPQExpBufferStr(q,
9408 "a.attcompression AS attcompression,\n");
9409 else
9410 appendPQExpBufferStr(q,
9411 "'' AS attcompression,\n");
9412
9414 appendPQExpBufferStr(q,
9415 "a.attidentity,\n");
9416 else
9417 appendPQExpBufferStr(q,
9418 "'' AS attidentity,\n");
9419
9421 appendPQExpBufferStr(q,
9422 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
9423 "THEN a.attmissingval ELSE null END AS attmissingval,\n");
9424 else
9425 appendPQExpBufferStr(q,
9426 "NULL AS attmissingval,\n");
9427
9429 appendPQExpBufferStr(q,
9430 "a.attgenerated\n");
9431 else
9432 appendPQExpBufferStr(q,
9433 "'' AS attgenerated\n");
9434
9435 /* need left join to pg_type to not fail on dropped columns ... */
9436 appendPQExpBuffer(q,
9437 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9438 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
9439 "LEFT JOIN pg_catalog.pg_type t "
9440 "ON (a.atttypid = t.oid)\n",
9441 tbloids->data);
9442
9443 /*
9444 * In versions 18 and up, we need pg_constraint for explicit NOT NULL
9445 * entries and pg_description to get their comments.
9446 */
9448 appendPQExpBufferStr(q,
9449 " LEFT JOIN pg_catalog.pg_constraint co ON "
9450 "(a.attrelid = co.conrelid\n"
9451 " AND co.contype = 'n' AND "
9452 "co.conkey = array[a.attnum])\n"
9453 " LEFT JOIN pg_catalog.pg_description pt ON "
9454 "(pt.classoid = co.tableoid AND pt.objoid = co.oid)\n");
9455
9456 appendPQExpBufferStr(q,
9457 "WHERE a.attnum > 0::pg_catalog.int2\n"
9458 "ORDER BY a.attrelid, a.attnum");
9459
9461
9462 ntups = PQntuples(res);
9463
9488
9489 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
9492
9493 /*
9494 * Outer loop iterates once per table, not once per row. Incrementing of
9495 * r is handled by the inner loop.
9496 */
9497 curtblindx = -1;
9498 for (int r = 0; r < ntups;)
9499 {
9502 int numatts;
9504
9505 /* Count rows for this table */
9506 for (numatts = 1; numatts < ntups - r; numatts++)
9508 break;
9509
9510 /*
9511 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
9512 * order.
9513 */
9515 {
9518 break;
9519 }
9522 /* cross-check that we only got requested tables */
9524 (!tbinfo->interesting &&
9529 tbinfo->dobj.name);
9530
9531 /* Save data for this table */
9532 tbinfo->numatts = numatts;
9556
9558 {
9561 tbinfo->dobj.name);
9566 else
9572 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
9577
9578 /* Handle not-null constraint name and flags */
9581 i_notnull_name,
9582 i_notnull_comment,
9583 i_notnull_invalidoid,
9584 i_notnull_noinherit,
9585 i_notnull_islocal,
9586 &invalidnotnulloids);
9587
9598 }
9599
9601 {
9602 /* Collect OIDs of interesting tables that have defaults */
9606 }
9607 }
9608
9609 /* If invalidnotnulloids has any data, finalize it */
9612
9613 PQclear(res);
9614
9615 /*
9616 * Now get info about column defaults. This is skipped for a data-only
9617 * dump, as it is only needed for table schemas.
9618 */
9620 {
9621 AttrDefInfo *attrdefs;
9624
9626
9628
9630 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc\n"
9631 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9632 "JOIN pg_catalog.pg_attrdef a ON (src.tbloid = a.adrelid)\n"
9633 "ORDER BY a.adrelid, a.adnum",
9634 tbloids->data);
9635
9637
9640
9641 curtblindx = -1;
9643 {
9649
9650 /*
9651 * Locate the associated TableInfo; we rely on tblinfo[] being in
9652 * OID order.
9653 */
9655 {
9657 {
9660 break;
9661 }
9664 }
9665
9668 adnum, tbinfo->dobj.name);
9669
9670 /*
9671 * dropped columns shouldn't have defaults, but just in case,
9672 * ignore 'em
9673 */
9675 continue;
9676
9684
9687
9689
9690 /*
9691 * Figure out whether the default/generation expression should be
9692 * dumped as part of the main CREATE TABLE (or similar) command or
9693 * as a separate ALTER TABLE (or similar) command. The preference
9694 * is to put it into the CREATE command, but in some cases that's
9695 * not possible.
9696 */
9698 {
9699 /*
9700 * Column generation expressions cannot be dumped separately,
9701 * because there is no syntax for it. By setting separate to
9702 * false here we prevent the "default" from being processed as
9703 * its own dumpable object. Later, flagInhAttrs() will mark
9704 * it as not to be dumped at all, if possible (that is, if it
9705 * can be inherited from a parent).
9706 */
9708 }
9710 {
9711 /*
9712 * Defaults on a VIEW must always be dumped as separate ALTER
9713 * TABLE commands.
9714 */
9716 }
9718 {
9719 /* column will be suppressed, print default separately */
9721 }
9722 else
9723 {
9725 }
9726
9728 {
9729 /*
9730 * Mark the default as needing to appear before the table, so
9731 * that any dependencies it has must be emitted before the
9732 * CREATE TABLE. If this is not possible, we'll change to
9733 * "separate" mode while sorting dependencies.
9734 */
9736 attrdefs[j].dobj.dumpId);
9737 }
9738
9740 }
9741
9742 PQclear(res);
9743 }
9744
9745 /*
9746 * Get info about NOT NULL NOT VALID constraints. This is skipped for a
9747 * data-only dump, as it is only needed for table schemas.
9748 */
9750 {
9759
9761
9762 resetPQExpBuffer(q);
9763 appendPQExpBuffer(q,
9764 "SELECT c.tableoid, c.oid, conrelid, conname, "
9765 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9766 "conislocal, convalidated "
9767 "FROM unnest('%s'::pg_catalog.oid[]) AS src(conoid)\n"
9768 "JOIN pg_catalog.pg_constraint c ON (src.conoid = c.oid)\n"
9769 "ORDER BY c.conrelid, c.conname",
9770 invalidnotnulloids->data);
9771
9773
9776
9783
9784 /* As above, this loop iterates once per table, not once per row */
9785 curtblindx = -1;
9787 {
9791
9792 /* Count rows for this table */
9795 break;
9796
9797 /*
9798 * Locate the associated TableInfo; we rely on tblinfo[] being in
9799 * OID order.
9800 */
9802 {
9805 break;
9806 }
9809
9811 {
9827
9828 /*
9829 * All invalid not-null constraints must be dumped separately,
9830 * because CREATE TABLE would not create them as invalid, and
9831 * also because they must be created after potentially
9832 * violating data has been loaded.
9833 */
9835
9837 }
9838 }
9839 PQclear(res);
9840 }
9841
9842 /*
9843 * Get info about table CHECK constraints. This is skipped for a
9844 * data-only dump, as it is only needed for table schemas.
9845 */
9847 {
9857
9859
9860 resetPQExpBuffer(q);
9861 appendPQExpBuffer(q,
9862 "SELECT c.tableoid, c.oid, conrelid, conname, "
9863 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9864 "conislocal, convalidated "
9865 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9866 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
9867 "WHERE contype = 'c' "
9868 "ORDER BY c.conrelid, c.conname",
9869 checkoids->data);
9870
9872
9875
9883
9884 /* As above, this loop iterates once per table, not once per row */
9885 curtblindx = -1;
9887 {
9891
9892 /* Count rows for this table */
9895 break;
9896
9897 /*
9898 * Locate the associated TableInfo; we rely on tblinfo[] being in
9899 * OID order.
9900 */
9902 {
9905 break;
9906 }
9909
9911 {
9913 "expected %d check constraints on table \"%s\" but found %d",
9914 tbinfo->ncheck),
9917 exit_nicely(1);
9918 }
9919
9921
9923 {
9925
9941
9942 /*
9943 * An unvalidated constraint needs to be dumped separately, so
9944 * that potentially-violating existing data is loaded before
9945 * the constraint.
9946 */
9948
9950
9951 /*
9952 * Mark the constraint as needing to appear before the table
9953 * --- this is so that any other dependencies of the
9954 * constraint will be emitted before we try to create the
9955 * table. If the constraint is to be dumped separately, it
9956 * will be dumped after data is loaded anyway, so don't do it.
9957 * (There's an automatic dependency in the opposite direction
9958 * anyway, so don't need to add one manually here.)
9959 */
9963
9964 /*
9965 * We will detect later whether the constraint must be split
9966 * out from the table definition.
9967 */
9968 }
9969 }
9970
9971 PQclear(res);
9972 }
9973
9974 destroyPQExpBuffer(q);
9977}
9978
9979/*
9980 * Based on the getTableAttrs query's row corresponding to one column, set
9981 * the name and flags to handle a not-null constraint for that column in
9982 * the tbinfo struct.
9983 *
9984 * Result row 'r' is for tbinfo's attribute 'j'.
9985 *
9986 * There are four possibilities:
9987 * 1) the column has no not-null constraints. In that case, ->notnull_constrs
9988 * (the constraint name) remains NULL.
9989 * 2) The column has a constraint with no name (this is the case when
9990 * constraints come from pre-18 servers). In this case, ->notnull_constrs
9991 * is set to the empty string; dumpTableSchema will print just "NOT NULL".
9992 * 3) The column has an invalid not-null constraint. This must be treated
9993 * as a separate object (because it must be created after the table data
9994 * is loaded). So we add its OID to invalidnotnulloids for processing
9995 * elsewhere and do nothing further with it here. We distinguish this
9996 * case because the "notnull_invalidoid" column has been set to a non-NULL
9997 * value, which is the constraint OID. Valid constraints have a null OID.
9998 * 4) The column has a constraint with a known name; in that case
9999 * notnull_constrs carries that name and dumpTableSchema will print
10000 * "CONSTRAINT the_name NOT NULL". However, if the name is the default
10001 * (table_column_not_null) and there's no comment on the constraint,
10002 * there's no need to print that name in the dump, so notnull_constrs
10003 * is set to the empty string and it behaves as case 2.
10004 *
10005 * In a child table that inherits from a parent already containing NOT NULL
10006 * constraints and the columns in the child don't have their own NOT NULL
10007 * declarations, we suppress printing constraints in the child: the
10008 * constraints are acquired at the point where the child is attached to the
10009 * parent. This is tracked in ->notnull_islocal; for servers pre-18 this is
10010 * set not here but in flagInhAttrs. That flag is also used when the
10011 * constraint was validated in a child but all its parent have it as NOT
10012 * VALID.
10013 *
10014 * Any of these constraints might have the NO INHERIT bit. If so we set
10015 * ->notnull_noinh and NO INHERIT will be printed by dumpTableSchema.
10016 *
10017 * In case 4 above, the name comparison is a bit of a hack; it actually fails
10018 * to do the right thing in all but the trivial case. However, the downside
10019 * of getting it wrong is simply that the name is printed rather than
10020 * suppressed, so it's not a big deal.
10021 *
10022 * invalidnotnulloids is expected to be given as NULL; if any invalid not-null
10023 * constraints are found, it is initialized and filled with the array of
10024 * OIDs of such constraints, for later processing.
10025 */
10026static void
10035{
10037
10038 /*
10039 * If this not-null constraint is not valid, list its OID in
10040 * invalidnotnulloids and do nothing further. It'll be processed
10041 * elsewhere later.
10042 *
10043 * Because invalid not-null constraints are rare, we don't want to malloc
10044 * invalidnotnulloids until we're sure we're going it need it, which
10045 * happens here.
10046 */
10048 {
10050
10052 {
10056 }
10057 else
10059
10060 /*
10061 * Track when a parent constraint is invalid for the cases where a
10062 * child constraint has been validated independenly.
10063 */
10065
10066 /* nothing else to do */
10068 return;
10069 }
10070
10071 /*
10072 * notnull_noinh is straight from the query result. notnull_islocal also,
10073 * though flagInhAttrs may change that one later.
10074 */
10078
10079 /*
10080 * Determine a constraint name to use. If the column is not marked not-
10081 * null, we set NULL which cues ... to do nothing. An empty string says
10082 * to print an unnamed NOT NULL, and anything else is a constraint name to
10083 * use.
10084 */
10086 {
10087 /*
10088 * < 18 doesn't have not-null names, so an unnamed constraint is
10089 * sufficient.
10090 */
10093 else
10095 }
10096 else
10097 {
10100 else
10101 {
10102 /*
10103 * In binary upgrade of inheritance child tables, must have a
10104 * constraint name that we can UPDATE later; same if there's a
10105 * comment on the constraint.
10106 */
10108 !tbinfo->ispartition &&
10109 !tbinfo->notnull_islocal) ||
10111 {
10114 }
10115 else
10116 {
10118
10119 /* XXX should match ChooseConstraintName better */
10125 else
10126 {
10129 }
10131 }
10132 }
10133 }
10134}
10135
10136/*
10137 * Test whether a column should be printed as part of table's CREATE TABLE.
10138 * Column number is zero-based.
10139 *
10140 * Normally this is always true, but it's false for dropped columns, as well
10141 * as those that were inherited without any local definition. (If we print
10142 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
10143 * For partitions, it's always true, because we want the partitions to be
10144 * created independently and ATTACH PARTITION used afterwards.
10145 *
10146 * In binary_upgrade mode, we must print all columns and fix the attislocal/
10147 * attisdropped state later, so as to keep control of the physical column
10148 * order.
10149 *
10150 * This function exists because there are scattered nonobvious places that
10151 * must be kept in sync with this decision.
10152 */
10153bool
10155{
10157 return true;
10159 return false;
10161}
10162
10163
10164/*
10165 * getTSParsers:
10166 * get information about all text search parsers in the system catalogs
10167 */
10168void
10170{
10171 PGresult *res;
10172 int ntups;
10174 PQExpBuffer query;
10185
10186 query = createPQExpBuffer();
10187
10188 /*
10189 * find all text search objects, including builtin ones; we filter out
10190 * system-defined objects at dump-out time.
10191 */
10192
10194 "prsstart::oid, prstoken::oid, "
10195 "prsend::oid, prsheadline::oid, prslextype::oid "
10196 "FROM pg_ts_parser");
10197
10199
10200 ntups = PQntuples(res);
10201
10203
10213
10215 {
10228
10229 /* Decide whether we want to dump it */
10231 }
10232
10233 PQclear(res);
10234
10235 destroyPQExpBuffer(query);
10236}
10237
10238/*
10239 * getTSDictionaries:
10240 * get information about all text search dictionaries in the system catalogs
10241 */
10242void
10244{
10245 PGresult *res;
10246 int ntups;
10248 PQExpBuffer query;
10257
10258 query = createPQExpBuffer();
10259
10261 "dictnamespace, dictowner, "
10262 "dicttemplate, dictinitoption "
10263 "FROM pg_ts_dict");
10264
10266
10267 ntups = PQntuples(res);
10268
10270
10278
10280 {
10292 else
10294
10295 /* Decide whether we want to dump it */
10297 }
10298
10299 PQclear(res);
10300
10301 destroyPQExpBuffer(query);
10302}
10303
10304/*
10305 * getTSTemplates:
10306 * get information about all text search templates in the system catalogs
10307 */
10308void
10310{
10311 PGresult *res;
10312 int ntups;
10314 PQExpBuffer query;
10322
10323 query = createPQExpBuffer();
10324
10326 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
10327 "FROM pg_ts_template");
10328
10330
10331 ntups = PQntuples(res);
10332
10334
10341
10343 {
10353
10354 /* Decide whether we want to dump it */
10356 }
10357
10358 PQclear(res);
10359
10360 destroyPQExpBuffer(query);
10361}
10362
10363/*
10364 * getTSConfigurations:
10365 * get information about all text search configurations
10366 */
10367void
10369{
10370 PGresult *res;
10371 int ntups;
10373 PQExpBuffer query;
10381
10382 query = createPQExpBuffer();
10383
10385 "cfgnamespace, cfgowner, cfgparser "
10386 "FROM pg_ts_config");
10387
10389
10390 ntups = PQntuples(res);
10391
10393
10400
10402 {
10412
10413 /* Decide whether we want to dump it */
10415 }
10416
10417 PQclear(res);
10418
10419 destroyPQExpBuffer(query);
10420}
10421
10422/*
10423 * getForeignDataWrappers:
10424 * get information about all foreign-data wrappers in the system catalogs
10425 */
10426void
10428{
10429 PGresult *res;
10430 int ntups;
10432 PQExpBuffer query;
10443
10444 query = createPQExpBuffer();
10445
10447 "fdwowner, "
10448 "fdwhandler::pg_catalog.regproc, "
10449 "fdwvalidator::pg_catalog.regproc, "
10450 "fdwacl, "
10451 "acldefault('F', fdwowner) AS acldefault, "
10452 "array_to_string(ARRAY("
10453 "SELECT quote_ident(option_name) || ' ' || "
10454 "quote_literal(option_value) "
10455 "FROM pg_options_to_table(fdwoptions) "
10456 "ORDER BY option_name"
10457 "), E',\n ') AS fdwoptions "
10458 "FROM pg_foreign_data_wrapper");
10459
10461
10462 ntups = PQntuples(res);
10463
10465
10475
10477 {
10492
10493 /* Decide whether we want to dump it */
10495
10496 /* Mark whether FDW has an ACL */
10499 }
10500
10501 PQclear(res);
10502
10503 destroyPQExpBuffer(query);
10504}
10505
10506/*
10507 * getForeignServers:
10508 * get information about all foreign servers in the system catalogs
10509 */
10510void
10512{
10513 PGresult *res;
10514 int ntups;
10516 PQExpBuffer query;
10528
10529 query = createPQExpBuffer();
10530
10532 "srvowner, "
10533 "srvfdw, srvtype, srvversion, srvacl, "
10534 "acldefault('S', srvowner) AS acldefault, "
10535 "array_to_string(ARRAY("
10536 "SELECT quote_ident(option_name) || ' ' || "
10537 "quote_literal(option_value) "
10538 "FROM pg_options_to_table(srvoptions) "
10539 "ORDER BY option_name"
10540 "), E',\n ') AS srvoptions "
10541 "FROM pg_foreign_server");
10542
10544
10545 ntups = PQntuples(res);
10546
10548
10559
10561 {
10577
10578 /* Decide whether we want to dump it */
10580
10581 /* Servers have user mappings */
10583
10584 /* Mark whether server has an ACL */
10587 }
10588
10589 PQclear(res);
10590
10591 destroyPQExpBuffer(query);
10592}
10593
10594/*
10595 * getDefaultACLs:
10596 * get information about all default ACL information in the system catalogs
10597 */
10598void
10600{
10603 PQExpBuffer query;
10604 PGresult *res;
10613 ntups;
10614
10615 query = createPQExpBuffer();
10616
10617 /*
10618 * Global entries (with defaclnamespace=0) replace the hard-wired default
10619 * ACL for their object type. We should dump them as deltas from the
10620 * default ACL, since that will be used as a starting point for
10621 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
10622 * non-global entries can only add privileges not revoke them. We must
10623 * dump those as-is (i.e., as deltas from an empty ACL).
10624 *
10625 * We can use defaclobjtype as the object type for acldefault(), except
10626 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
10627 * 's'.
10628 */
10629 appendPQExpBufferStr(query,
10630 "SELECT oid, tableoid, "
10631 "defaclrole, "
10632 "defaclnamespace, "
10633 "defaclobjtype, "
10634 "defaclacl, "
10635 "CASE WHEN defaclnamespace = 0 THEN "
10636 "acldefault(CASE WHEN defaclobjtype = 'S' "
10637 "THEN 's'::\"char\" ELSE defaclobjtype END, "
10638 "defaclrole) ELSE '{}' END AS acldefault "
10639 "FROM pg_default_acl");
10640
10642
10643 ntups = PQntuples(res);
10644
10646
10654
10656 {
10658
10663 /* cheesy ... is it worth coming up with a better object name? */
10665
10668 else
10670
10677
10678 /* Default ACLs are ACLs, of course */
10680
10681 /* Decide whether we want to dump it */
10683 }
10684
10685 PQclear(res);
10686
10687 destroyPQExpBuffer(query);
10688}
10689
10690/*
10691 * getRoleName -- look up the name of a role, given its OID
10692 *
10693 * In current usage, we don't expect failures, so error out for a bad OID.
10694 */
10695static const char *
10697{
10699
10700 /*
10701 * Do binary search to find the appropriate item.
10702 */
10704 {
10707
10708 while (low <= high)
10709 {
10711
10713 high = middle - 1;
10715 low = middle + 1;
10716 else
10718 }
10719 }
10720
10723}
10724
10725/*
10726 * collectRoleNames --
10727 *
10728 * Construct a table of all known roles.
10729 * The table is sorted by OID for speed in lookup.
10730 */
10731static void
10733{
10734 PGresult *res;
10735 const char *query;
10737
10738 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10739
10741
10743
10745
10747 {
10750 }
10751
10752 PQclear(res);
10753}
10754
10755/*
10756 * getAdditionalACLs
10757 *
10758 * We have now created all the DumpableObjects, and collected the ACL data
10759 * that appears in the directly-associated catalog entries. However, there's
10760 * more ACL-related info to collect. If any of a table's columns have ACLs,
10761 * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
10762 * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
10763 * Also, in versions having the pg_init_privs catalog, read that and load the
10764 * information into the relevant DumpableObjects.
10765 */
10766static void
10768{
10770 PGresult *res;
10771 int ntups,
10772 i;
10773
10774 /* Check for per-column ACLs */
10775 appendPQExpBufferStr(query,
10776 "SELECT DISTINCT attrelid FROM pg_attribute "
10777 "WHERE attacl IS NOT NULL");
10778
10780
10781 ntups = PQntuples(res);
10783 {
10785 TableInfo *tblinfo;
10786
10787 tblinfo = findTableByOid(relid);
10788 /* OK to ignore tables we haven't got a DumpableObject for */
10789 if (tblinfo)
10790 {
10793 }
10794 }
10795 PQclear(res);
10796
10797 /* Fetch initial-privileges data */
10799 {
10800 printfPQExpBuffer(query,
10801 "SELECT objoid, classoid, objsubid, privtype, initprivs "
10802 "FROM pg_init_privs");
10803
10805
10806 ntups = PQntuples(res);
10808 {
10814 CatalogId objId;
10815 DumpableObject *dobj;
10816
10817 objId.tableoid = classoid;
10818 objId.oid = objoid;
10819 dobj = findObjectByCatalogId(objId);
10820 /* OK to ignore entries we haven't got a DumpableObject for */
10821 if (dobj)
10822 {
10823 /* Cope with sub-object initprivs */
10824 if (objsubid != 0)
10825 {
10827 {
10828 /* For a column initprivs, set the table's ACL flags */
10831 }
10832 else
10834 classoid, objoid, objsubid);
10835 continue;
10836 }
10837
10838 /*
10839 * We ignore any pg_init_privs.initprivs entry for the public
10840 * schema, as explained in getNamespaces().
10841 */
10844 continue;
10845
10846 /* Else it had better be of a type we think has ACLs */
10855 {
10857
10860 }
10861 else
10863 classoid, objoid, objsubid);
10864 }
10865 }
10866 PQclear(res);
10867 }
10868
10869 destroyPQExpBuffer(query);
10870}
10871
10872/*
10873 * dumpCommentExtended --
10874 *
10875 * This routine is used to dump any comments associated with the
10876 * object handed to this routine. The routine takes the object type
10877 * and object name (ready to print, except for schema decoration), plus
10878 * the namespace and owner of the object (for labeling the ArchiveEntry),
10879 * plus catalog ID and subid which are the lookup key for pg_description,
10880 * plus the dump ID for the object (for setting a dependency).
10881 * If a matching pg_description entry is found, it is dumped.
10882 *
10883 * Note: in some cases, such as comments for triggers and rules, the "type"
10884 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
10885 * but it doesn't seem worth complicating the API for all callers to make
10886 * it cleaner.
10887 *
10888 * Note: although this routine takes a dumpId for dependency purposes,
10889 * that purpose is just to mark the dependency in the emitted dump file
10890 * for possible future use by pg_restore. We do NOT use it for determining
10891 * ordering of the comment in the dump file, because this routine is called
10892 * after dependency sorting occurs. This routine should be called just after
10893 * calling ArchiveEntry() for the specified object.
10894 */
10895static void
10901{
10905
10906 /* do nothing, if --no-comments is supplied */
10908 return;
10909
10910 /* Comments are schema not data ... except LO comments are data */
10912 {
10914 return;
10915 }
10916 else
10917 {
10918 /* We do dump LO comments in binary-upgrade mode */
10920 return;
10921 }
10922
10923 /* Search for comments associated with catalogId, using table */
10925 &comments);
10926
10927 /* Is there one matching the subid? */
10929 {
10931 break;
10932 comments++;
10933 ncomments--;
10934 }
10935
10937 {
10939
10940 /*
10941 * initdb creates this object with a comment. Skip dumping the
10942 * initdb-provided comment, which would complicate matters for
10943 * non-superuser use of pg_dump. When the DBA has removed initdb's
10944 * comment, replicate that.
10945 */
10947 {
10949 ncomments = 1;
10950 }
10952 ncomments = 0;
10953 }
10954
10955 /* If a comment exists, build COMMENT ON statement */
10957 {
10960
10962 if (namespace && *namespace)
10967
10969
10970 /*
10971 * We mark comments as SECTION_NONE because they really belong in the
10972 * same section as their parent, whether that is pre-data or
10973 * post-data.
10974 */
10977 .namespace = namespace,
10978 .owner = owner,
10979 .description = "COMMENT",
10980 .section = SECTION_NONE,
10981 .createStmt = query->data,
10982 .deps = &dumpId,
10983 .nDeps = 1));
10984
10985 destroyPQExpBuffer(query);
10986 destroyPQExpBuffer(tag);
10987 }
10988}
10989
10990/*
10991 * dumpComment --
10992 *
10993 * Typical simplification of the above function.
10994 */
10995static inline void
11000{
11002 catalogId, subid, dumpId, NULL);
11003}
11004
11005/*
11006 * appendNamedArgument --
11007 *
11008 * Convenience routine for constructing parameters of the form:
11009 * 'paraname', 'value'::type
11010 */
11011static void
11014{
11016
11019
11022}
11023
11024/*
11025 * fetchAttributeStats --
11026 *
11027 * Fetch next batch of attribute statistics for dumpRelationStats_dumper().
11028 */
11031{
11035 int count = 0;
11040
11041 /*
11042 * Our query for retrieving statistics for multiple relations uses WITH
11043 * ORDINALITY and multi-argument UNNEST(), both of which were introduced
11044 * in v9.4. For older versions, we resort to gathering statistics for a
11045 * single relation at a time.
11046 */
11048 max_rels = 1;
11049
11050 /* If we're just starting, set our TOC pointer. */
11051 if (!te)
11053
11054 /*
11055 * We can't easily avoid a second TOC scan for the tar format because it
11056 * writes restore.sql separately, which means we must execute the queries
11057 * twice. This feels risky, but there is no known reason it should
11058 * generate different output than the first pass. Even if it does, the
11059 * worst-case scenario is that restore.sql might have different statistics
11060 * data than the archive.
11061 */
11063 {
11066 }
11067
11070
11071 /*
11072 * Scan the TOC for the next set of relevant stats entries. We assume
11073 * that statistics are dumped in the order they are listed in the TOC.
11074 * This is perhaps not the sturdiest assumption, so we verify it matches
11075 * reality in dumpRelationStats_dumper().
11076 */
11078 {
11081 {
11084 count++;
11085 }
11086 }
11087
11090
11091 /* Execute the query for the next batch of relations. */
11092 if (count > 0)
11093 {
11095
11102 destroyPQExpBuffer(query);
11103 }
11104
11107 return res;
11108}
11109
11110/*
11111 * dumpRelationStats_dumper --
11112 *
11113 * Generate command to import stats into the relation on the new database.
11114 * This routine is called by the Archiver when it wants the statistics to be
11115 * dumped.
11116 */
11117static char *
11119{
11122 static int rownum;
11123 PQExpBuffer query;
11144
11145 /*
11146 * fetchAttributeStats() assumes that the statistics are dumped in the
11147 * order they are listed in the TOC. We verify that here for safety.
11148 */
11151
11156
11161
11162 query = createPQExpBuffer();
11164 {
11165 appendPQExpBufferStr(query,
11166 "PREPARE getAttributeStats(pg_catalog.name[], pg_catalog.name[]) AS\n"
11167 "SELECT s.schemaname, s.tablename, s.attname, s.inherited, "
11168 "s.null_frac, s.avg_width, s.n_distinct, "
11169 "s.most_common_vals, s.most_common_freqs, "
11170 "s.histogram_bounds, s.correlation, "
11171 "s.most_common_elems, s.most_common_elem_freqs, "
11172 "s.elem_count_histogram, ");
11173
11175 appendPQExpBufferStr(query,
11176 "s.range_length_histogram, "
11177 "s.range_empty_frac, "
11178 "s.range_bounds_histogram ");
11179 else
11180 appendPQExpBufferStr(query,
11181 "NULL AS range_length_histogram,"
11182 "NULL AS range_empty_frac,"
11183 "NULL AS range_bounds_histogram ");
11184
11185 /*
11186 * The results must be in the order of the relations supplied in the
11187 * parameters to ensure we remain in sync as we walk through the TOC.
11188 * The redundant filter clause on s.tablename = ANY(...) seems
11189 * sufficient to convince the planner to use
11190 * pg_class_relname_nsp_index, which avoids a full scan of pg_stats.
11191 * This may not work for all versions.
11192 *
11193 * Our query for retrieving statistics for multiple relations uses
11194 * WITH ORDINALITY and multi-argument UNNEST(), both of which were
11195 * introduced in v9.4. For older versions, we resort to gathering
11196 * statistics for a single relation at a time.
11197 */
11199 appendPQExpBufferStr(query,
11200 "FROM pg_catalog.pg_stats s "
11201 "JOIN unnest($1, $2) WITH ORDINALITY AS u (schemaname, tablename, ord) "
11202 "ON s.schemaname = u.schemaname "
11203 "AND s.tablename = u.tablename "
11204 "WHERE s.tablename = ANY($2) "
11205 "ORDER BY u.ord, s.attname, s.inherited");
11206 else
11207 appendPQExpBufferStr(query,
11208 "FROM pg_catalog.pg_stats s "
11209 "WHERE s.schemaname = $1[1] "
11210 "AND s.tablename = $2[1] "
11211 "ORDER BY s.attname, s.inherited");
11212
11214
11216 resetPQExpBuffer(query);
11217 }
11218
11219 initPQExpBuffer(out);
11220
11221 /* restore relation stats */
11224 fout->remoteVersion);
11232
11233 /*
11234 * Before v14, a reltuples value of 0 was ambiguous: it could either mean
11235 * the relation is empty, or it could mean that it hadn't yet been
11236 * vacuumed or analyzed. (Newer versions use -1 for the latter case.)
11237 * This ambiguity allegedly can cause the planner to choose inefficient
11238 * plans after restoring to v18 or newer. To deal with this, let's just
11239 * set reltuples to -1 in that case.
11240 */
11243 else
11245
11247 rsinfo->relallvisible);
11248
11251
11253
11254 /* Fetch the next batch of attribute statistics if needed. */
11256 {
11257 PQclear(res);
11259 rownum = 0;
11260 }
11261
11279
11280 /* restore attribute stats */
11282 {
11284
11285 /* Stop if the next stat row in our cache isn't for this relation. */
11288 break;
11289
11292 fout->remoteVersion);
11297
11301
11302 /*
11303 * Indexes look up attname in indAttNames to derive attnum, all others
11304 * use attname directly. We must specify attnum for indexes, since
11305 * their attnames are not necessarily stable across dump/reload.
11306 */
11308 {
11311 }
11312 else
11313 {
11314 bool found = false;
11315
11317 {
11319 {
11321 i + 1);
11322 found = true;
11323 break;
11324 }
11325 }
11326
11327 if (!found)
11329 }
11330
11365 {
11375 }
11377 }
11378
11379 destroyPQExpBuffer(query);
11381}
11382
11383/*
11384 * dumpRelationStats --
11385 *
11386 * Make an ArchiveEntry for the relation statistics. The Archiver will take
11387 * care of gathering the statistics and generating the restore commands when
11388 * they are needed.
11389 */
11390static void
11392{
11394
11395 /* nothing to do if we are not dumping statistics */
11397 return;
11398
11401 .namespace = dobj->namespace->dobj.name,
11402 .description = "STATISTICS DATA",
11403 .section = rsinfo->section,
11404 .defnFn = dumpRelationStats_dumper,
11405 .defnArg = rsinfo,
11406 .deps = dobj->dependencies,
11407 .nDeps = dobj->nDeps));
11408}
11409
11410/*
11411 * dumpTableComment --
11412 *
11413 * As above, but dump comments for both the specified table (or view)
11414 * and its columns.
11415 */
11416static void
11419{
11423 PQExpBuffer query;
11424 PQExpBuffer tag;
11425
11426 /* do nothing, if --no-comments is supplied */
11428 return;
11429
11430 /* Comments are SCHEMA not data */
11432 return;
11433
11434 /* Search for comments associated with relation, using table */
11436 tbinfo->dobj.catId.oid,
11437 &comments);
11438
11439 /* If comments exist, build COMMENT ON statements */
11441 return;
11442
11443 query = createPQExpBuffer();
11444 tag = createPQExpBuffer();
11445
11447 {
11450
11451 if (objsubid == 0)
11452 {
11453 resetPQExpBuffer(tag);
11456
11457 resetPQExpBuffer(query);
11462
11465 .namespace = tbinfo->dobj.namespace->dobj.name,
11466 .owner = tbinfo->rolname,
11467 .description = "COMMENT",
11468 .section = SECTION_NONE,
11469 .createStmt = query->data,
11470 .deps = &(tbinfo->dobj.dumpId),
11471 .nDeps = 1));
11472 }
11474 {
11475 resetPQExpBuffer(tag);
11479
11480 resetPQExpBuffer(query);
11487
11490 .namespace = tbinfo->dobj.namespace->dobj.name,
11491 .owner = tbinfo->rolname,
11492 .description = "COMMENT",
11493 .section = SECTION_NONE,
11494 .createStmt = query->data,
11495 .deps = &(tbinfo->dobj.dumpId),
11496 .nDeps = 1));
11497 }
11498
11499 comments++;
11500 ncomments--;
11501 }
11502
11503 destroyPQExpBuffer(query);
11504 destroyPQExpBuffer(tag);
11505}
11506
11507/*
11508 * findComments --
11509 *
11510 * Find the comment(s), if any, associated with the given object. All the
11511 * objsubid values associated with the given classoid/objoid are found with
11512 * one search.
11513 */
11514static int
11516{
11518 CommentItem *low;
11519 CommentItem *high;
11520 int nmatch;
11521
11522 /*
11523 * Do binary search to find some item matching the object.
11524 */
11525 low = &comments[0];
11527 while (low <= high)
11528 {
11529 middle = low + (high - low) / 2;
11530
11532 high = middle - 1;
11534 low = middle + 1;
11536 high = middle - 1;
11538 low = middle + 1;
11539 else
11540 break; /* found a match */
11541 }
11542
11543 if (low > high) /* no matches */
11544 {
11546 return 0;
11547 }
11548
11549 /*
11550 * Now determine how many items match the object. The search loop
11551 * invariant still holds: only items between low and high inclusive could
11552 * match.
11553 */
11554 nmatch = 1;
11556 {
11558 objoid != middle[-1].objoid)
11559 break;
11560 middle--;
11561 nmatch++;
11562 }
11563
11565
11566 middle += nmatch;
11568 {
11570 objoid != middle->objoid)
11571 break;
11572 middle++;
11573 nmatch++;
11574 }
11575
11576 return nmatch;
11577}
11578
11579/*
11580 * collectComments --
11581 *
11582 * Construct a table of all comments available for database objects;
11583 * also set the has-comment component flag for each relevant object.
11584 *
11585 * We used to do per-object queries for the comments, but it's much faster
11586 * to pull them all over at once, and on most databases the memory cost
11587 * isn't high.
11588 *
11589 * The table is sorted by classoid/objid/objsubid for speed in lookup.
11590 */
11591static void
11593{
11594 PGresult *res;
11595 PQExpBuffer query;
11600 int ntups;
11602 DumpableObject *dobj;
11603
11604 query = createPQExpBuffer();
11605
11607 "FROM pg_catalog.pg_description "
11608 "ORDER BY classoid, objoid, objsubid");
11609
11611
11612 /* Construct lookup table containing OIDs in numeric form */
11613
11618
11619 ntups = PQntuples(res);
11620
11622 ncomments = 0;
11623 dobj = NULL;
11624
11626 {
11627 CatalogId objId;
11628 int subid;
11629
11633
11634 /* We needn't remember comments that don't match any dumpable object */
11638 dobj = findObjectByCatalogId(objId);
11640 continue;
11641
11642 /*
11643 * Comments on columns of composite types are linked to the type's
11644 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11645 * in the type's own DumpableObject.
11646 */
11649 {
11651
11655 }
11656 else
11657 dobj->components |= DUMP_COMPONENT_COMMENT;
11658
11663 ncomments++;
11664 }
11665
11666 PQclear(res);
11667 destroyPQExpBuffer(query);
11668}
11669
11670/*
11671 * dumpDumpableObject
11672 *
11673 * This routine and its subsidiaries are responsible for creating
11674 * ArchiveEntries (TOC objects) for each object to be dumped.
11675 */
11676static void
11678{
11679 /*
11680 * Clear any dump-request bits for components that don't exist for this
11681 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
11682 * request for every kind of object.)
11683 */
11685
11686 /* Now, short-circuit if there's nothing to be done here. */
11688 return;
11689
11691 {
11694 break;
11697 break;
11700 break;
11703 break;
11706 break;
11709 break;
11712 break;
11715 break;
11718 break;
11721 break;
11724 break;
11727 break;
11730 break;
11733 break;
11736 break;
11739 break;
11742 break;
11746 break;
11749 break;
11752 break;
11755 break;
11758 break;
11761 break;
11764 break;
11767 break;
11770 break;
11773 break;
11776 break;
11779 break;
11781 /* table rowtypes and array types are never dumped separately */
11782 break;
11785 break;
11788 break;
11791 break;
11794 break;
11797 break;
11800 break;
11803 break;
11806 break;
11809 {
11811 TocEntry *te;
11812
11816 dobj->name);
11817
11820 .owner = loinfo->rolname,
11821 .description = "BLOBS",
11822 .section = SECTION_DATA,
11823 .deps = dobj->dependencies,
11824 .nDeps = dobj->nDeps,
11825 .dumpFn = dumpLOs,
11826 .dumpArg = loinfo));
11827
11828 /*
11829 * Set the TocEntry's dataLength in case we are doing a
11830 * parallel dump and want to order dump jobs by table size.
11831 * (We need some size estimate for every TocEntry with a
11832 * DataDumper function.) We don't currently have any cheap
11833 * way to estimate the size of LOs, but fortunately it doesn't
11834 * matter too much as long as we get large batches of LOs
11835 * processed reasonably early. Assume 8K per blob.
11836 */
11838 }
11839 break;
11842 break;
11845 break;
11848 break;
11852 break;
11855 break;
11858 break;
11861 break;
11864 /* never dumped, nothing to do */
11865 break;
11866 }
11867}
11868
11869/*
11870 * dumpNamespace
11871 * writes out to fout the queries to recreate a user-defined namespace
11872 */
11873static void
11875{
11877 PQExpBuffer q;
11880
11881 /* Do nothing if not dumping schema */
11883 return;
11884
11885 q = createPQExpBuffer();
11887
11889
11891 {
11894 }
11895 else
11896 {
11897 /* see selectDumpableNamespace() */
11899 "-- *not* dropping schema, since initdb creates it\n");
11900 appendPQExpBufferStr(q,
11901 "-- *not* creating schema, since initdb creates it\n");
11902 }
11903
11907
11911 .owner = nspinfo->rolname,
11912 .description = "SCHEMA",
11913 .section = SECTION_PRE_DATA,
11914 .createStmt = q->data,
11915 .dropStmt = delq->data));
11916
11917 /* Dump Schema Comments and Security Labels */
11919 {
11921
11927 initdb_comment);
11928 }
11929
11934
11939
11941
11942 destroyPQExpBuffer(q);
11944}
11945
11946/*
11947 * dumpExtension
11948 * writes out to fout the queries to recreate an extension
11949 */
11950static void
11952{
11954 PQExpBuffer q;
11957
11958 /* Do nothing if not dumping schema */
11960 return;
11961
11962 q = createPQExpBuffer();
11964
11966
11968
11970 {
11971 /*
11972 * In a regular dump, we simply create the extension, intentionally
11973 * not specifying a version, so that the destination installation's
11974 * default version is used.
11975 *
11976 * Use of IF NOT EXISTS here is unlike our behavior for other object
11977 * types; but there are various scenarios in which it's convenient to
11978 * manually create the desired extension before restoring, so we
11979 * prefer to allow it to exist already.
11980 */
11983 }
11984 else
11985 {
11986 /*
11987 * In binary-upgrade mode, it's critical to reproduce the state of the
11988 * database exactly, so our procedure is to create an empty extension,
11989 * restore all the contained objects normally, and add them to the
11990 * extension one by one. This function performs just the first of
11991 * those steps. binary_upgrade_extension_member() takes care of
11992 * adding member objects as they're created.
11993 */
11995 int n;
11996
11997 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
11998
11999 /*
12000 * We unconditionally create the extension, so we must drop it if it
12001 * exists. This could happen if the user deleted 'plpgsql' and then
12002 * readded it, causing its oid to be greater than g_last_builtin_oid.
12003 */
12005
12006 appendPQExpBufferStr(q,
12007 "SELECT pg_catalog.binary_upgrade_create_empty_extension(");
12015
12016 /*
12017 * Note that we're pushing extconfig (an OID array) back into
12018 * pg_extension exactly as-is. This is OK because pg_class OIDs are
12019 * preserved in binary upgrade.
12020 */
12023 else
12028 else
12032 n = 0;
12034 {
12036
12039 {
12040 if (n++ > 0)
12043 }
12044 }
12047 }
12048
12052 .description = "EXTENSION",
12053 .section = SECTION_PRE_DATA,
12054 .createStmt = q->data,
12055 .dropStmt = delq->data));
12056
12057 /* Dump Extension Comments */
12062
12064
12065 destroyPQExpBuffer(q);
12067}
12068
12069/*
12070 * dumpType
12071 * writes out to fout the queries to recreate a user-defined type
12072 */
12073static void
12075{
12077
12078 /* Do nothing if not dumping schema */
12080 return;
12081
12082 /* Dump out in proper style */
12095 else
12097 tyinfo->dobj.name);
12098}
12099
12100/*
12101 * dumpEnumType
12102 * writes out to fout the queries to recreate a user-defined enum type
12103 */
12104static void
12106{
12111 PGresult *res;
12112 int num,
12113 i;
12114 Oid enum_oid;
12120
12122 {
12123 /* Set up query for enum-specific details */
12124 appendPQExpBufferStr(query,
12125 "PREPARE dumpEnumType(pg_catalog.oid) AS\n"
12126 "SELECT oid, enumlabel "
12127 "FROM pg_catalog.pg_enum "
12128 "WHERE enumtypid = $1 "
12129 "ORDER BY enumsortorder");
12130
12132
12134 }
12135
12136 printfPQExpBuffer(query,
12137 "EXECUTE dumpEnumType('%u')",
12138 tyinfo->dobj.catId.oid);
12139
12141
12142 num = PQntuples(res);
12143
12146
12147 /*
12148 * CASCADE shouldn't be required here as for normal types since the I/O
12149 * functions are generic and do not get dropped.
12150 */
12152
12155 tyinfo->dobj.catId.oid,
12156 false, false);
12157
12159 qualtypname);
12160
12162 {
12164
12165 /* Labels with server-assigned oids */
12167 {
12173 }
12174 }
12175
12177
12179 {
12182
12183 /* Labels with dump-assigned (preserved) oids */
12185 {
12188
12191 appendPQExpBuffer(q,
12192 "SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
12193 enum_oid);
12197 }
12198 }
12199
12203 tyinfo->dobj.namespace->dobj.name);
12204
12208 .namespace = tyinfo->dobj.namespace->dobj.name,
12209 .owner = tyinfo->rolname,
12210 .description = "TYPE",
12211 .section = SECTION_PRE_DATA,
12212 .createStmt = q->data,
12213 .dropStmt = delq->data));
12214
12215 /* Dump Type Comments and Security Labels */
12220
12225
12229 tyinfo->dobj.namespace->dobj.name,
12231
12232 PQclear(res);
12233 destroyPQExpBuffer(q);
12235 destroyPQExpBuffer(query);
12238}
12239
12240/*
12241 * dumpRangeType
12242 * writes out to fout the queries to recreate a user-defined range type
12243 */
12244static void
12246{
12251 PGresult *res;
12255 char *procname;
12256
12258 {
12259 /* Set up query for range-specific details */
12260 appendPQExpBufferStr(query,
12261 "PREPARE dumpRangeType(pg_catalog.oid) AS\n");
12262
12263 appendPQExpBufferStr(query,
12264 "SELECT ");
12265
12267 appendPQExpBufferStr(query,
12268 "pg_catalog.format_type(rngmultitypid, NULL) AS rngmultitype, ");
12269 else
12270 appendPQExpBufferStr(query,
12271 "NULL AS rngmultitype, ");
12272
12273 appendPQExpBufferStr(query,
12274 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
12275 "opc.opcname AS opcname, "
12276 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
12277 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
12278 "opc.opcdefault, "
12279 "CASE WHEN rngcollation = st.typcollation THEN 0 "
12280 " ELSE rngcollation END AS collation, "
12281 "rngcanonical, rngsubdiff "
12282 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
12283 " pg_catalog.pg_opclass opc "
12284 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
12285 "rngtypid = $1");
12286
12288
12290 }
12291
12292 printfPQExpBuffer(query,
12293 "EXECUTE dumpRangeType('%u')",
12294 tyinfo->dobj.catId.oid);
12295
12297
12300
12301 /*
12302 * CASCADE shouldn't be required here as for normal types since the I/O
12303 * functions are generic and do not get dropped.
12304 */
12306
12309 tyinfo->dobj.catId.oid,
12310 false, true);
12311
12313 qualtypname);
12314
12317
12321
12322 /* print subtype_opclass only if not default for subtype */
12324 {
12327
12329 fmtId(nspname));
12331 }
12332
12335 {
12337
12341 }
12342
12346
12350
12352
12356 tyinfo->dobj.namespace->dobj.name);
12357
12361 .namespace = tyinfo->dobj.namespace->dobj.name,
12362 .owner = tyinfo->rolname,
12363 .description = "TYPE",
12364 .section = SECTION_PRE_DATA,
12365 .createStmt = q->data,
12366 .dropStmt = delq->data));
12367
12368 /* Dump Type Comments and Security Labels */
12373
12378
12382 tyinfo->dobj.namespace->dobj.name,
12384
12385 PQclear(res);
12386 destroyPQExpBuffer(q);
12388 destroyPQExpBuffer(query);
12391}
12392
12393/*
12394 * dumpUndefinedType
12395 * writes out to fout the queries to recreate a !typisdefined type
12396 *
12397 * This is a shell type, but we use different terminology to distinguish
12398 * this case from where we have to emit a shell type definition to break
12399 * circular dependencies. An undefined type shouldn't ever have anything
12400 * depending on it.
12401 */
12402static void
12404{
12410
12413
12415
12418 tyinfo->dobj.catId.oid,
12419 false, false);
12420
12422 qualtypname);
12423
12427 tyinfo->dobj.namespace->dobj.name);
12428
12432 .namespace = tyinfo->dobj.namespace->dobj.name,
12433 .owner = tyinfo->rolname,
12434 .description = "TYPE",
12435 .section = SECTION_PRE_DATA,
12436 .createStmt = q->data,
12437 .dropStmt = delq->data));
12438
12439 /* Dump Type Comments and Security Labels */
12444
12449
12453 tyinfo->dobj.namespace->dobj.name,
12455
12456 destroyPQExpBuffer(q);
12460}
12461
12462/*
12463 * dumpBaseType
12464 * writes out to fout the queries to recreate a user-defined base type
12465 */
12466static void
12468{
12473 PGresult *res;
12476 char *typlen;
12478 char *typoutput;
12479 char *typreceive;
12480 char *typsend;
12484 char *typsubscript;
12493 char *typdelim;
12494 char *typbyval;
12496 char *typstorage;
12500
12502 {
12503 /* Set up query for type-specific details */
12504 appendPQExpBufferStr(query,
12505 "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
12506 "SELECT typlen, "
12507 "typinput, typoutput, typreceive, typsend, "
12508 "typreceive::pg_catalog.oid AS typreceiveoid, "
12509 "typsend::pg_catalog.oid AS typsendoid, "
12510 "typanalyze, "
12511 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
12512 "typdelim, typbyval, typalign, typstorage, "
12513 "typmodin, typmodout, "
12514 "typmodin::pg_catalog.oid AS typmodinoid, "
12515 "typmodout::pg_catalog.oid AS typmodoutoid, "
12516 "typcategory, typispreferred, "
12517 "(typcollation <> 0) AS typcollatable, "
12518 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
12519
12521 appendPQExpBufferStr(query,
12522 "typsubscript, "
12523 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
12524 else
12525 appendPQExpBufferStr(query,
12526 "'-' AS typsubscript, 0 AS typsubscriptoid ");
12527
12529 "WHERE oid = $1");
12530
12532
12534 }
12535
12536 printfPQExpBuffer(query,
12537 "EXECUTE dumpBaseType('%u')",
12538 tyinfo->dobj.catId.oid);
12539
12541
12567 {
12570 }
12571 else
12573
12576
12577 /*
12578 * The reason we include CASCADE is that the circular dependency between
12579 * the type and its I/O functions makes it impossible to drop the type any
12580 * other way.
12581 */
12583
12584 /*
12585 * We might already have a shell type, but setting pg_type_oid is
12586 * harmless, and in any case we'd better set the array type OID.
12587 */
12590 tyinfo->dobj.catId.oid,
12591 false, false);
12592
12593 appendPQExpBuffer(q,
12594 "CREATE TYPE %s (\n"
12595 " INTERNALLENGTH = %s",
12596 qualtypname,
12598
12599 /* regproc result is sufficiently quoted already */
12612
12615
12617 {
12621 else
12623 }
12624
12627
12631 zeroIsError));
12632
12634 {
12637 }
12638
12641
12643 {
12646 }
12647
12656
12665
12668
12670
12674 tyinfo->dobj.namespace->dobj.name);
12675
12679 .namespace = tyinfo->dobj.namespace->dobj.name,
12680 .owner = tyinfo->rolname,
12681 .description = "TYPE",
12682 .section = SECTION_PRE_DATA,
12683 .createStmt = q->data,
12684 .dropStmt = delq->data));
12685
12686 /* Dump Type Comments and Security Labels */
12691
12696
12700 tyinfo->dobj.namespace->dobj.name,
12702
12703 PQclear(res);
12704 destroyPQExpBuffer(q);
12706 destroyPQExpBuffer(query);
12709}
12710
12711/*
12712 * dumpDomain
12713 * writes out to fout the queries to recreate a user-defined domain
12714 */
12715static void
12717{
12722 PGresult *res;
12729 Oid typcollation;
12731
12733 {
12734 /* Set up query for domain-specific details */
12735 appendPQExpBufferStr(query,
12736 "PREPARE dumpDomain(pg_catalog.oid) AS\n");
12737
12739 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
12740 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
12741 "t.typdefault, "
12742 "CASE WHEN t.typcollation <> u.typcollation "
12743 "THEN t.typcollation ELSE 0 END AS typcollation "
12744 "FROM pg_catalog.pg_type t "
12745 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
12746 "WHERE t.oid = $1");
12747
12749
12751 }
12752
12753 printfPQExpBuffer(query,
12754 "EXECUTE dumpDomain('%u')",
12755 tyinfo->dobj.catId.oid);
12756
12758
12764 {
12767 }
12768 else
12771
12774 tyinfo->dobj.catId.oid,
12775 true, /* force array type */
12776 false); /* force multirange type */
12777
12780
12781 appendPQExpBuffer(q,
12782 "CREATE DOMAIN %s AS %s",
12783 qualtypname,
12784 typdefn);
12785
12786 /* Print collation only if different from base type's collation */
12788 {
12790
12794 }
12795
12796 /*
12797 * Print a not-null constraint if there's one. In servers older than 17
12798 * these don't have names, so just print it unadorned; in newer ones they
12799 * do, but most of the time it's going to be the standard generated one,
12800 * so omit the name in that case also.
12801 */
12803 {
12806 else
12807 {
12809
12811 {
12813
12814 /* XXX should match ChooseConstraintName better */
12816
12819 else
12823 }
12824 }
12825 }
12826
12828 {
12832 else
12834 }
12835
12836 PQclear(res);
12837
12838 /*
12839 * Add any CHECK constraints for the domain
12840 */
12842 {
12844
12848 }
12849
12851
12853
12857 tyinfo->dobj.namespace->dobj.name);
12858
12862 .namespace = tyinfo->dobj.namespace->dobj.name,
12863 .owner = tyinfo->rolname,
12864 .description = "DOMAIN",
12865 .section = SECTION_PRE_DATA,
12866 .createStmt = q->data,
12867 .dropStmt = delq->data));
12868
12869 /* Dump Domain Comments and Security Labels */
12874
12879
12883 tyinfo->dobj.namespace->dobj.name,
12885
12886 /* Dump any per-constraint comments */
12888 {
12891
12892 /* but only if the constraint itself was dumped here */
12894 continue;
12895
12899
12902 tyinfo->dobj.namespace->dobj.name,
12903 tyinfo->rolname,
12905
12907 }
12908
12909 /*
12910 * And a comment on the not-null constraint, if there's one -- but only if
12911 * the constraint itself was dumped here
12912 */
12914 {
12916
12919
12922 tyinfo->dobj.namespace->dobj.name,
12923 tyinfo->rolname,
12926 }
12927
12928 destroyPQExpBuffer(q);
12930 destroyPQExpBuffer(query);
12933}
12934
12935/*
12936 * dumpCompositeType
12937 * writes out to fout the queries to recreate a user-defined stand-alone
12938 * composite type
12939 */
12940static void
12942{
12948 PGresult *res;
12951 int ntups;
12960
12962 {
12963 /*
12964 * Set up query for type-specific details.
12965 *
12966 * Since we only want to dump COLLATE clauses for attributes whose
12967 * collation is different from their type's default, we use a CASE
12968 * here to suppress uninteresting attcollations cheaply. atttypid
12969 * will be 0 for dropped columns; collation does not matter for those.
12970 */
12971 appendPQExpBufferStr(query,
12972 "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
12973 "SELECT a.attname, a.attnum, "
12974 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
12975 "a.attlen, a.attalign, a.attisdropped, "
12976 "CASE WHEN a.attcollation <> at.typcollation "
12977 "THEN a.attcollation ELSE 0 END AS attcollation "
12978 "FROM pg_catalog.pg_type ct "
12979 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
12980 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
12981 "WHERE ct.oid = $1 "
12982 "ORDER BY a.attnum");
12983
12985
12987 }
12988
12989 printfPQExpBuffer(query,
12990 "EXECUTE dumpCompositeType('%u')",
12991 tyinfo->dobj.catId.oid);
12992
12994
12995 ntups = PQntuples(res);
12996
13003
13005 {
13007 tyinfo->dobj.catId.oid,
13008 false, false);
13010 }
13011
13014
13016 qualtypname);
13017
13018 actual_atts = 0;
13020 {
13025 bool attisdropped;
13026 Oid attcollation;
13027
13034
13036 continue;
13037
13038 /* Format properly if not first attr */
13042
13043 if (!attisdropped)
13044 {
13046
13047 /* Add collation if not default for the column type */
13049 {
13051
13056 }
13057 }
13058 else
13059 {
13060 /*
13061 * This is a dropped attribute and we're in binary_upgrade mode.
13062 * Insert a placeholder for it in the CREATE TYPE command, and set
13063 * length and alignment with direct UPDATE to the catalogs
13064 * afterwards. See similar code in dumpTableSchema().
13065 */
13067
13068 /* stash separately for insertion after the CREATE TYPE */
13069 appendPQExpBufferStr(dropped,
13070 "\n-- For binary upgrade, recreate dropped column.\n");
13072 "SET attlen = %s, "
13073 "attalign = '%s', attbyval = false\n"
13079
13081 qualtypname);
13084 }
13085 }
13088
13090
13094 tyinfo->dobj.namespace->dobj.name);
13095
13099 .namespace = tyinfo->dobj.namespace->dobj.name,
13100 .owner = tyinfo->rolname,
13101 .description = "TYPE",
13102 .section = SECTION_PRE_DATA,
13103 .createStmt = q->data,
13104 .dropStmt = delq->data));
13105
13106
13107 /* Dump Type Comments and Security Labels */
13112
13117
13121 tyinfo->dobj.namespace->dobj.name,
13123
13124 /* Dump any per-column comments */
13127
13128 PQclear(res);
13129 destroyPQExpBuffer(q);
13130 destroyPQExpBuffer(dropped);
13132 destroyPQExpBuffer(query);
13135}
13136
13137/*
13138 * dumpCompositeTypeColComments
13139 * writes out to fout the queries to recreate comments on the columns of
13140 * a user-defined stand-alone composite type.
13141 *
13142 * The caller has already made a query to collect the names and attnums
13143 * of the type's columns, so we just pass that result into here rather
13144 * than reading them again.
13145 */
13146static void
13148 PGresult *res)
13149{
13152 PQExpBuffer query;
13153 PQExpBuffer target;
13155 int ntups;
13159
13160 /* do nothing, if --no-comments is supplied */
13162 return;
13163
13164 /* Search for comments associated with type's pg_class OID */
13166 &comments);
13167
13168 /* If no comments exist, we're done */
13170 return;
13171
13172 /* Build COMMENT ON statements */
13173 query = createPQExpBuffer();
13174 target = createPQExpBuffer();
13175
13176 ntups = PQntuples(res);
13181 {
13183
13186 {
13189 {
13191 break;
13192 }
13193 }
13195 {
13197
13198 resetPQExpBuffer(target);
13202
13203 resetPQExpBuffer(query);
13209
13212 .namespace = tyinfo->dobj.namespace->dobj.name,
13213 .owner = tyinfo->rolname,
13214 .description = "COMMENT",
13215 .section = SECTION_NONE,
13216 .createStmt = query->data,
13217 .deps = &(tyinfo->dobj.dumpId),
13218 .nDeps = 1));
13219 }
13220
13221 comments++;
13222 ncomments--;
13223 }
13224
13225 destroyPQExpBuffer(query);
13226 destroyPQExpBuffer(target);
13227}
13228
13229/*
13230 * dumpShellType
13231 * writes out to fout the queries to create a shell type
13232 *
13233 * We dump a shell definition in advance of the I/O functions for the type.
13234 */
13235static void
13237{
13239 PQExpBuffer q;
13240
13241 /* Do nothing if not dumping schema */
13243 return;
13244
13245 q = createPQExpBuffer();
13246
13247 /*
13248 * Note the lack of a DROP command for the shell type; any required DROP
13249 * is driven off the base type entry, instead. This interacts with
13250 * _printTocEntry()'s use of the presence of a DROP command to decide
13251 * whether an entry needs an ALTER OWNER command. We don't want to alter
13252 * the shell type's owner immediately on creation; that should happen only
13253 * after it's filled in, otherwise the backend complains.
13254 */
13255
13258 stinfo->baseType->dobj.catId.oid,
13259 false, false);
13260
13263
13267 .namespace = stinfo->dobj.namespace->dobj.name,
13268 .owner = stinfo->baseType->rolname,
13269 .description = "SHELL TYPE",
13270 .section = SECTION_PRE_DATA,
13271 .createStmt = q->data));
13272
13273 destroyPQExpBuffer(q);
13274}
13275
13276/*
13277 * dumpProcLang
13278 * writes out to fout the queries to recreate a user-defined
13279 * procedural language
13280 */
13281static void
13283{
13292
13293 /* Do nothing if not dumping schema */
13295 return;
13296
13297 /*
13298 * Try to find the support function(s). It is not an error if we don't
13299 * find them --- if the functions are in the pg_catalog schema, as is
13300 * standard in 8.1 and up, then we won't have loaded them. (In this case
13301 * we will emit a parameterless CREATE LANGUAGE command, which will
13302 * require PL template knowledge in the backend to reload.)
13303 */
13304
13308
13310 {
13314 }
13315
13317 {
13321 }
13322
13323 /*
13324 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
13325 * parameters. Otherwise, we'll write a parameterless command, which will
13326 * be interpreted as CREATE EXTENSION.
13327 */
13331
13334
13336
13338 qlanname);
13339
13341 {
13344 qlanname);
13353 }
13354 else
13355 {
13356 /*
13357 * If not dumping parameters, then use CREATE OR REPLACE so that the
13358 * command will not fail if the language is preinstalled in the target
13359 * database.
13360 *
13361 * Modern servers will interpret this as CREATE EXTENSION IF NOT
13362 * EXISTS; perhaps we should emit that instead? But it might just add
13363 * confusion.
13364 */
13366 qlanname);
13367 }
13369
13373
13377 .owner = plang->lanowner,
13378 .description = "PROCEDURAL LANGUAGE",
13379 .section = SECTION_PRE_DATA,
13380 .createStmt = defqry->data,
13381 .dropStmt = delqry->data,
13382 ));
13383
13384 /* Dump Proc Lang Comments and Security Labels */
13389
13394
13399
13401
13404}
13405
13406/*
13407 * format_function_arguments: generate function name and argument list
13408 *
13409 * This is used when we can rely on pg_get_function_arguments to format
13410 * the argument list. Note, however, that pg_get_function_arguments
13411 * does not special-case zero-argument aggregates.
13412 */
13413static char *
13415{
13417
13422 else
13425}
13426
13427/*
13428 * format_function_signature: generate function name and argument list
13429 *
13430 * Only a minimal list of input argument types is generated; this is
13431 * sufficient to reference the function, but not to define it.
13432 *
13433 * If honor_quotes is false then the function name is never quoted.
13434 * This is appropriate for use in TOC tags, but not in SQL commands.
13435 */
13436static char *
13438{
13441
13445 else
13448 {
13451
13454 zeroIsError));
13455 }
13458}
13459
13460
13461/*
13462 * dumpFunc:
13463 * dump out one function
13464 */
13465static void
13467{
13469 PQExpBuffer query;
13470 PQExpBuffer q;
13473 PGresult *res;
13479 char *prosrc;
13486 char *prokind;
13499 const char *keyword;
13500
13501 /* Do nothing if not dumping schema */
13503 return;
13504
13505 query = createPQExpBuffer();
13506 q = createPQExpBuffer();
13509
13511 {
13512 /* Set up query for function-specific details */
13513 appendPQExpBufferStr(query,
13514 "PREPARE dumpFunc(pg_catalog.oid) AS\n");
13515
13516 appendPQExpBufferStr(query,
13517 "SELECT\n"
13518 "proretset,\n"
13519 "prosrc,\n"
13520 "probin,\n"
13521 "provolatile,\n"
13522 "proisstrict,\n"
13523 "prosecdef,\n"
13524 "lanname,\n"
13525 "proconfig,\n"
13526 "procost,\n"
13527 "prorows,\n"
13528 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
13529 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n"
13530 "pg_catalog.pg_get_function_result(p.oid) AS funcresult,\n"
13531 "proleakproof,\n");
13532
13534 appendPQExpBufferStr(query,
13535 "array_to_string(protrftypes, ' ') AS protrftypes,\n");
13536 else
13537 appendPQExpBufferStr(query,
13538 "NULL AS protrftypes,\n");
13539
13541 appendPQExpBufferStr(query,
13542 "proparallel,\n");
13543 else
13544 appendPQExpBufferStr(query,
13545 "'u' AS proparallel,\n");
13546
13548 appendPQExpBufferStr(query,
13549 "prokind,\n");
13550 else
13551 appendPQExpBufferStr(query,
13552 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind,\n");
13553
13555 appendPQExpBufferStr(query,
13556 "prosupport,\n");
13557 else
13558 appendPQExpBufferStr(query,
13559 "'-' AS prosupport,\n");
13560
13562 appendPQExpBufferStr(query,
13563 "pg_get_function_sqlbody(p.oid) AS prosqlbody\n");
13564 else
13565 appendPQExpBufferStr(query,
13566 "NULL AS prosqlbody\n");
13567
13568 appendPQExpBufferStr(query,
13569 "FROM pg_catalog.pg_proc p, pg_catalog.pg_language l\n"
13570 "WHERE p.oid = $1 "
13571 "AND l.oid = p.prolang");
13572
13574
13576 }
13577
13578 printfPQExpBuffer(query,
13579 "EXECUTE dumpFunc('%u')",
13581
13583
13586 {
13590 }
13591 else
13592 {
13593 prosrc = NULL;
13596 }
13612
13613 /*
13614 * See backend/commands/functioncmds.c for details of how the 'AS' clause
13615 * is used.
13616 */
13618 {
13620 }
13622 {
13625 if (prosrc[0] != '\0')
13626 {
13628
13629 /*
13630 * where we have bin, use dollar quoting if allowed and src
13631 * contains quote or backslash; else use regular quoting.
13632 */
13636 else
13638 }
13639 }
13640 else
13641 {
13643 /* with no bin, dollar quote src unconditionally if allowed */
13646 else
13648 }
13649
13651 {
13654 }
13655 else
13656 {
13658 nconfigitems = 0;
13659 }
13660
13663
13665
13668 funcsig);
13669
13671 keyword = "PROCEDURE";
13672 else
13673 keyword = "FUNCTION"; /* works for window functions too */
13674
13676 keyword, qual_funcsig);
13677
13679 keyword,
13682 funcsig);
13683
13685 /* no result type to output */ ;
13688 else
13692 zeroIsError));
13693
13695
13697 {
13700
13704 {
13709 }
13710
13712 }
13713
13716
13718 {
13726 }
13727
13730
13733
13736
13737 /*
13738 * COST and ROWS are emitted only if present and not default, so as not to
13739 * break backwards-compatibility of the dump without need. Keep this code
13740 * in sync with the defaults in functioncmds.c.
13741 */
13743 {
13745 {
13746 /* default cost is 1 */
13749 }
13750 else
13751 {
13752 /* default cost is 100 */
13755 }
13756 }
13760
13762 {
13763 /* We rely on regprocout to provide quoting and qualification */
13765 }
13766
13768 {
13776 }
13777
13779 {
13780 /* we feel free to scribble on configitems[] here */
13782 char *pos;
13783
13786 continue;
13787 *pos++ = '\0';
13789
13790 /*
13791 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
13792 * by flatten_set_variable_args() before they were put into the
13793 * proconfig array. However, because the quoting rules used there
13794 * aren't exactly like SQL's, we have to break the list value apart
13795 * and then quote the elements as string literals. (The elements may
13796 * be double-quoted as-is, but we can't just feed them to the SQL
13797 * parser; it would do the wrong thing with elements that are
13798 * zero-length or longer than NAMEDATALEN.) Also, we need a special
13799 * case for empty lists.
13800 *
13801 * Variables that are not so marked should just be emitted as simple
13802 * string literals. If the variable is not known to
13803 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
13804 * to use GUC_LIST_QUOTE for extension variables.
13805 */
13807 {
13810
13811 /* Parse string into list of identifiers */
13812 /* this shouldn't fail really */
13814 {
13815 /* Special case: represent an empty list as NULL */
13819 {
13823 }
13824 }
13826 }
13827 else
13829 }
13830
13832
13834 "pg_catalog.pg_proc", keyword,
13835 qual_funcsig);
13836
13839 keyword, funcsig,
13841
13846 .owner = finfo->rolname,
13847 .description = keyword,
13848 .section = finfo->postponed_def ?
13850 .createStmt = q->data,
13852
13853 /* Dump Function Comments and Security Labels */
13858
13863
13869
13870 PQclear(res);
13871
13872 destroyPQExpBuffer(query);
13873 destroyPQExpBuffer(q);
13881}
13882
13883
13884/*
13885 * Dump a user-defined cast
13886 */
13887static void
13889{
13898
13899 /* Do nothing if not dumping schema */
13901 return;
13902
13903 /* Cannot dump if we don't have the cast function's info */
13905 {
13909 cast->castfunc);
13910 }
13911
13916
13921
13924
13926 {
13929 break;
13932 break;
13935 {
13937
13938 /*
13939 * Always qualify the function name (format_function_signature
13940 * won't qualify it).
13941 */
13945 }
13946 else
13948 break;
13949 default:
13951 }
13952
13958
13961
13964
13968
13972 .description = "CAST",
13973 .section = SECTION_PRE_DATA,
13974 .createStmt = defqry->data,
13975 .dropStmt = delqry->data));
13976
13977 /* Dump Cast Comments */
13982
13987}
13988
13989/*
13990 * Dump a transform
13991 */
13992static void
13994{
14004
14005 /* Do nothing if not dumping schema */
14007 return;
14008
14009 /* Cannot dump if we don't have the transform functions' info */
14011 {
14015 transform->trffromsql);
14016 }
14018 {
14022 transform->trftosql);
14023 }
14024
14029
14032
14035
14038
14040 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
14041
14043 {
14045 {
14047
14048 /*
14049 * Always qualify the function name (format_function_signature
14050 * won't qualify it).
14051 */
14055 }
14056 else
14058 }
14059
14061 {
14064
14066 {
14068
14069 /*
14070 * Always qualify the function name (format_function_signature
14071 * won't qualify it).
14072 */
14076 }
14077 else
14079 }
14080
14082
14085
14088
14092
14096 .description = "TRANSFORM",
14097 .section = SECTION_PRE_DATA,
14098 .createStmt = defqry->data,
14099 .dropStmt = delqry->data,
14102
14103 /* Dump Transform Comments */
14108
14114}
14115
14116
14117/*
14118 * dumpOpr
14119 * write out a single operator definition
14120 */
14121static void
14123{
14125 PQExpBuffer query;
14126 PQExpBuffer q;
14129 PQExpBuffer details;
14130 PGresult *res;
14141 char *oprkind;
14142 char *oprcode;
14143 char *oprleft;
14144 char *oprright;
14153
14154 /* Do nothing if not dumping schema */
14156 return;
14157
14158 /*
14159 * some operators are invalid because they were the result of user
14160 * defining operators before commutators exist
14161 */
14163 return;
14164
14165 query = createPQExpBuffer();
14166 q = createPQExpBuffer();
14169 details = createPQExpBuffer();
14170
14172 {
14173 /* Set up query for operator-specific details */
14174 appendPQExpBufferStr(query,
14175 "PREPARE dumpOpr(pg_catalog.oid) AS\n"
14176 "SELECT oprkind, "
14177 "oprcode::pg_catalog.regprocedure, "
14178 "oprleft::pg_catalog.regtype, "
14179 "oprright::pg_catalog.regtype, "
14180 "oprcom, "
14181 "oprnegate, "
14182 "oprrest::pg_catalog.regprocedure, "
14183 "oprjoin::pg_catalog.regprocedure, "
14184 "oprcanmerge, oprcanhash "
14185 "FROM pg_catalog.pg_operator "
14186 "WHERE oid = $1");
14187
14189
14191 }
14192
14193 printfPQExpBuffer(query,
14194 "EXECUTE dumpOpr('%u')",
14195 oprinfo->dobj.catId.oid);
14196
14198
14209
14220
14221 /* In PG14 upwards postfix operator support does not exist anymore. */
14224 oprcode);
14225
14228 {
14231 }
14232
14234 oprinfo->dobj.name);
14235
14236 /*
14237 * right unary means there's a left arg and left unary means there's a
14238 * right arg. (Although the "r" case is dead code for PG14 and later,
14239 * continue to support it in case we're dumping from an old server.)
14240 */
14243 {
14246 }
14247 else
14249
14252 {
14255 }
14256 else
14258
14261 {
14264 }
14265
14268 {
14271 }
14272
14275
14278
14281 {
14284 }
14285
14288 {
14291 }
14292
14295 oprid->data);
14296
14300
14304 oprinfo->dobj.namespace->dobj.name);
14305
14309 .namespace = oprinfo->dobj.namespace->dobj.name,
14310 .owner = oprinfo->rolname,
14311 .description = "OPERATOR",
14312 .section = SECTION_PRE_DATA,
14313 .createStmt = q->data,
14314 .dropStmt = delq->data));
14315
14316 /* Dump Operator Comments */
14321
14322 PQclear(res);
14323
14324 destroyPQExpBuffer(query);
14325 destroyPQExpBuffer(q);
14328 destroyPQExpBuffer(details);
14329}
14330
14331/*
14332 * Convert a function reference obtained from pg_operator
14333 *
14334 * Returns allocated string of what to print, or NULL if function references
14335 * is InvalidOid. Returned string is expected to be free'd by the caller.
14336 *
14337 * The input is a REGPROCEDURE display; we have to strip the argument-types
14338 * part.
14339 */
14340static char *
14342{
14346
14347 /* In all cases "-" means a null reference */
14350
14352 /* find non-double-quoted left paren */
14355 {
14357 {
14359 break;
14360 }
14363 }
14365}
14366
14367/*
14368 * getFormattedOperatorName - retrieve the operator name for the
14369 * given operator OID (presented in string form).
14370 *
14371 * Returns an allocated string, or NULL if the given OID is invalid.
14372 * Caller is responsible for free'ing result string.
14373 *
14374 * What we produce has the format "OPERATOR(schema.oprname)". This is only
14375 * useful in commands where the operator's argument types can be inferred from
14376 * context. We always schema-qualify the name, though. The predecessor to
14377 * this code tried to skip the schema qualification if possible, but that led
14378 * to wrong results in corner cases, such as if an operator and its negator
14379 * are in different schemas.
14380 */
14381static char *
14383{
14385
14386 /* In all cases "0" means a null reference */
14389
14392 {
14394 oproid);
14396 }
14397
14400 oprInfo->dobj.name);
14401}
14402
14403/*
14404 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
14405 *
14406 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
14407 * argument lists of these functions are predetermined. Note that the
14408 * caller should ensure we are in the proper schema, because the results
14409 * are search path dependent!
14410 */
14411static char *
14413{
14414 char *result;
14415 char query[128];
14416 PGresult *res;
14417
14419 "SELECT '%u'::pg_catalog.regproc", funcOid);
14421
14423
14424 PQclear(res);
14425
14426 return result;
14427}
14428
14429/*
14430 * dumpAccessMethod
14431 * write out a single access method definition
14432 */
14433static void
14435{
14437 PQExpBuffer q;
14440
14441 /* Do nothing if not dumping schema */
14443 return;
14444
14445 q = createPQExpBuffer();
14447
14449
14451
14453 {
14456 break;
14459 break;
14460 default:
14463 destroyPQExpBuffer(q);
14466 return;
14467 }
14468
14470
14472 qamname);
14473
14477
14481 .description = "ACCESS METHOD",
14482 .section = SECTION_PRE_DATA,
14483 .createStmt = q->data,
14484 .dropStmt = delq->data));
14485
14486 /* Dump Access Method Comments */
14491
14492 destroyPQExpBuffer(q);
14495}
14496
14497/*
14498 * dumpOpclass
14499 * write out a single operator class definition
14500 */
14501static void
14503{
14505 PQExpBuffer query;
14506 PQExpBuffer q;
14509 PGresult *res;
14510 int ntups;
14526 char *opcintype;
14529 char *opcfamily;
14532 char *amname;
14535 char *sortfamily;
14543
14544 /* Do nothing if not dumping schema */
14546 return;
14547
14548 query = createPQExpBuffer();
14549 q = createPQExpBuffer();
14552
14553 /* Get additional fields from the pg_opclass row */
14555 "opckeytype::pg_catalog.regtype, "
14556 "opcdefault, opcfamily, "
14557 "opfname AS opcfamilyname, "
14558 "nspname AS opcfamilynsp, "
14559 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
14560 "FROM pg_catalog.pg_opclass c "
14561 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
14562 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14563 "WHERE c.oid = '%u'::pg_catalog.oid",
14564 opcinfo->dobj.catId.oid);
14565
14567
14575
14576 /* opcintype may still be needed after we PQclear res */
14580 /* opcfamily will still be needed after we PQclear res */
14584 /* amname will still be needed after we PQclear res */
14586
14590 fmtId(amname));
14591
14592 /* Build the fixed portion of the CREATE command */
14598 opcintype,
14599 fmtId(amname));
14601 {
14605 }
14607
14609
14611 {
14613 opckeytype);
14615 }
14616
14617 PQclear(res);
14618
14619 /*
14620 * Now fetch and print the OPERATOR entries (pg_amop rows).
14621 *
14622 * Print only those opfamily members that are tied to the opclass by
14623 * pg_depend entries.
14624 */
14625 resetPQExpBuffer(query);
14627 "amopopr::pg_catalog.regoperator, "
14628 "opfname AS sortfamily, "
14629 "nspname AS sortfamilynsp "
14630 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14631 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14632 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14633 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14634 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14635 "AND refobjid = '%u'::pg_catalog.oid "
14636 "AND amopfamily = '%s'::pg_catalog.oid "
14637 "ORDER BY amopstrategy",
14638 opcinfo->dobj.catId.oid,
14639 opcfamily);
14640
14642
14643 ntups = PQntuples(res);
14644
14649
14651 {
14656
14659
14662
14664 {
14668 }
14669
14671 }
14672
14673 PQclear(res);
14674
14675 /*
14676 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14677 *
14678 * Print only those opfamily members that are tied to the opclass by
14679 * pg_depend entries.
14680 *
14681 * We print the amproclefttype/amprocrighttype even though in most cases
14682 * the backend could deduce the right values, because of the corner case
14683 * of a btree sort support function for a cross-type comparison.
14684 */
14685 resetPQExpBuffer(query);
14686
14688 "amproc::pg_catalog.regprocedure, "
14689 "amproclefttype::pg_catalog.regtype, "
14690 "amprocrighttype::pg_catalog.regtype "
14691 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14692 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14693 "AND refobjid = '%u'::pg_catalog.oid "
14694 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14695 "AND objid = ap.oid "
14696 "ORDER BY amprocnum",
14697 opcinfo->dobj.catId.oid);
14698
14700
14701 ntups = PQntuples(res);
14702
14707
14709 {
14714
14717
14719
14722
14724
14726 }
14727
14728 PQclear(res);
14729
14730 /*
14731 * If needComma is still false it means we haven't added anything after
14732 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
14733 * clause with the same datatype. This isn't sanctioned by the
14734 * documentation, but actually DefineOpClass will treat it as a no-op.
14735 */
14738
14740
14743 fmtId(amname));
14744
14748 opcinfo->dobj.namespace->dobj.name);
14749
14753 .namespace = opcinfo->dobj.namespace->dobj.name,
14754 .owner = opcinfo->rolname,
14755 .description = "OPERATOR CLASS",
14756 .section = SECTION_PRE_DATA,
14757 .createStmt = q->data,
14758 .dropStmt = delq->data));
14759
14760 /* Dump Operator Class Comments */
14765
14766 free(opcintype);
14767 free(opcfamily);
14768 free(amname);
14769 destroyPQExpBuffer(query);
14770 destroyPQExpBuffer(q);
14773}
14774
14775/*
14776 * dumpOpfamily
14777 * write out a single operator family definition
14778 *
14779 * Note: this also dumps any "loose" operator members that aren't bound to a
14780 * specific opclass within the opfamily.
14781 */
14782static void
14784{
14786 PQExpBuffer query;
14787 PQExpBuffer q;
14790 PGresult *res;
14793 int ntups;
14803 char *amname;
14806 char *sortfamily;
14814
14815 /* Do nothing if not dumping schema */
14817 return;
14818
14819 query = createPQExpBuffer();
14820 q = createPQExpBuffer();
14823
14824 /*
14825 * Fetch only those opfamily members that are tied directly to the
14826 * opfamily by pg_depend entries.
14827 */
14829 "amopopr::pg_catalog.regoperator, "
14830 "opfname AS sortfamily, "
14831 "nspname AS sortfamilynsp "
14832 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14833 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14834 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14835 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14836 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14837 "AND refobjid = '%u'::pg_catalog.oid "
14838 "AND amopfamily = '%u'::pg_catalog.oid "
14839 "ORDER BY amopstrategy",
14840 opfinfo->dobj.catId.oid,
14841 opfinfo->dobj.catId.oid);
14842
14844
14845 resetPQExpBuffer(query);
14846
14848 "amproc::pg_catalog.regprocedure, "
14849 "amproclefttype::pg_catalog.regtype, "
14850 "amprocrighttype::pg_catalog.regtype "
14851 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14852 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14853 "AND refobjid = '%u'::pg_catalog.oid "
14854 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14855 "AND objid = ap.oid "
14856 "ORDER BY amprocnum",
14857 opfinfo->dobj.catId.oid);
14858
14860
14861 /* Get additional fields from the pg_opfamily row */
14862 resetPQExpBuffer(query);
14863
14865 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
14866 "FROM pg_catalog.pg_opfamily "
14867 "WHERE oid = '%u'::pg_catalog.oid",
14868 opfinfo->dobj.catId.oid);
14869
14871
14873
14874 /* amname will still be needed after we PQclear res */
14876
14880 fmtId(amname));
14881
14882 /* Build the fixed portion of the CREATE command */
14886 fmtId(amname));
14887
14888 PQclear(res);
14889
14890 /* Do we need an ALTER to add loose members? */
14892 {
14896 fmtId(amname));
14897
14899
14900 /*
14901 * Now fetch and print the OPERATOR entries (pg_amop rows).
14902 */
14904
14909
14911 {
14916
14919
14922
14924 {
14928 }
14929
14931 }
14932
14933 /*
14934 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14935 */
14937
14942
14944 {
14949
14952
14955 amproc);
14956
14958 }
14959
14961 }
14962
14965 fmtId(amname));
14966
14970 opfinfo->dobj.namespace->dobj.name);
14971
14975 .namespace = opfinfo->dobj.namespace->dobj.name,
14976 .owner = opfinfo->rolname,
14977 .description = "OPERATOR FAMILY",
14978 .section = SECTION_PRE_DATA,
14979 .createStmt = q->data,
14980 .dropStmt = delq->data));
14981
14982 /* Dump Operator Family Comments */
14987
14988 free(amname);
14991 destroyPQExpBuffer(query);
14992 destroyPQExpBuffer(q);
14995}
14996
14997/*
14998 * dumpCollation
14999 * write out a single collation definition
15000 */
15001static void
15003{
15005 PQExpBuffer query;
15006 PQExpBuffer q;
15009 PGresult *res;
15021
15022 /* Do nothing if not dumping schema */
15024 return;
15025
15026 query = createPQExpBuffer();
15027 q = createPQExpBuffer();
15029
15031
15032 /* Get collation-specific details */
15034
15036 appendPQExpBufferStr(query,
15037 "collprovider, "
15038 "collversion, ");
15039 else
15040 appendPQExpBufferStr(query,
15041 "'c' AS collprovider, "
15042 "NULL AS collversion, ");
15043
15045 appendPQExpBufferStr(query,
15046 "collisdeterministic, ");
15047 else
15048 appendPQExpBufferStr(query,
15049 "true AS collisdeterministic, ");
15050
15052 appendPQExpBufferStr(query,
15053 "colllocale, ");
15055 appendPQExpBufferStr(query,
15056 "colliculocale AS colllocale, ");
15057 else
15058 appendPQExpBufferStr(query,
15059 "NULL AS colllocale, ");
15060
15062 appendPQExpBufferStr(query,
15063 "collicurules, ");
15064 else
15065 appendPQExpBufferStr(query,
15066 "NULL AS collicurules, ");
15067
15068 appendPQExpBuffer(query,
15069 "collcollate, "
15070 "collctype "
15071 "FROM pg_catalog.pg_collation c "
15072 "WHERE c.oid = '%u'::pg_catalog.oid",
15073 collinfo->dobj.catId.oid);
15074
15076
15083
15085
15088 else
15090
15093 else
15095
15096 /*
15097 * Before version 15, collcollate and collctype were of type NAME and
15098 * non-nullable. Treat empty strings as NULL for consistency.
15099 */
15101 {
15106 }
15107
15110 else
15112
15115 else
15117
15120
15123
15132 /* to allow dumping pg_catalog; not accepted on input */
15134 else
15136 collprovider);
15137
15140
15142 {
15145
15146 /* no locale -- the default collation cannot be reloaded anyway */
15147 }
15149 {
15152
15155 fout);
15156 }
15158 {
15160 {
15163
15166 fout);
15167 }
15168 else
15169 {
15173
15176 }
15177
15179 {
15182 }
15183 }
15185 {
15188
15190 {
15193 }
15194 else
15195 {
15200 }
15201 }
15202 else
15204
15205 /*
15206 * For binary upgrade, carry over the collation version. For normal
15207 * dump/restore, omit the version, so that it is computed upon restore.
15208 */
15210 {
15212
15215 {
15217 appendStringLiteralAH(q,
15219 fout);
15220 }
15221 }
15222
15224
15228 collinfo->dobj.namespace->dobj.name);
15229
15233 .namespace = collinfo->dobj.namespace->dobj.name,
15234 .owner = collinfo->rolname,
15235 .description = "COLLATION",
15236 .section = SECTION_PRE_DATA,
15237 .createStmt = q->data,
15238 .dropStmt = delq->data));
15239
15240 /* Dump Collation Comments */
15245
15246 PQclear(res);
15247
15248 destroyPQExpBuffer(query);
15249 destroyPQExpBuffer(q);
15252}
15253
15254/*
15255 * dumpConversion
15256 * write out a single conversion definition
15257 */
15258static void
15260{
15262 PQExpBuffer query;
15263 PQExpBuffer q;
15266 PGresult *res;
15275
15276 /* Do nothing if not dumping schema */
15278 return;
15279
15280 query = createPQExpBuffer();
15281 q = createPQExpBuffer();
15283
15285
15286 /* Get conversion-specific details */
15288 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
15289 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
15290 "conproc, condefault "
15291 "FROM pg_catalog.pg_conversion c "
15292 "WHERE c.oid = '%u'::pg_catalog.oid",
15293 convinfo->dobj.catId.oid);
15294
15296
15301
15306
15309
15316 /* regproc output is already sufficiently quoted */
15318
15322 convinfo->dobj.namespace->dobj.name);
15323
15327 .namespace = convinfo->dobj.namespace->dobj.name,
15328 .owner = convinfo->rolname,
15329 .description = "CONVERSION",
15330 .section = SECTION_PRE_DATA,
15331 .createStmt = q->data,
15332 .dropStmt = delq->data));
15333
15334 /* Dump Conversion Comments */
15339
15340 PQclear(res);
15341
15342 destroyPQExpBuffer(query);
15343 destroyPQExpBuffer(q);
15346}
15347
15348/*
15349 * format_aggregate_signature: generate aggregate name and argument list
15350 *
15351 * The argument type names are qualified if needed. The aggregate name
15352 * is never qualified.
15353 */
15354static char *
15356{
15359
15363 else
15365
15368 else
15369 {
15376 zeroIsError));
15378 }
15380}
15381
15382/*
15383 * dumpAgg
15384 * write out a single aggregate definition
15385 */
15386static void
15388{
15390 PQExpBuffer query;
15391 PQExpBuffer q;
15393 PQExpBuffer details;
15397 PGresult *res;
15412 const char *aggsortop;
15415 const char *aggtranstype;
15416 const char *aggtransspace;
15423
15424 /* Do nothing if not dumping schema */
15426 return;
15427
15428 query = createPQExpBuffer();
15429 q = createPQExpBuffer();
15431 details = createPQExpBuffer();
15432
15434 {
15435 /* Set up query for aggregate-specific details */
15436 appendPQExpBufferStr(query,
15437 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15438
15439 appendPQExpBufferStr(query,
15440 "SELECT "
15441 "aggtransfn,\n"
15442 "aggfinalfn,\n"
15443 "aggtranstype::pg_catalog.regtype,\n"
15444 "agginitval,\n"
15445 "aggsortop,\n"
15446 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15447 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15448
15450 appendPQExpBufferStr(query,
15451 "aggkind,\n"
15452 "aggmtransfn,\n"
15453 "aggminvtransfn,\n"
15454 "aggmfinalfn,\n"
15455 "aggmtranstype::pg_catalog.regtype,\n"
15456 "aggfinalextra,\n"
15457 "aggmfinalextra,\n"
15458 "aggtransspace,\n"
15459 "aggmtransspace,\n"
15460 "aggminitval,\n");
15461 else
15462 appendPQExpBufferStr(query,
15463 "'n' AS aggkind,\n"
15464 "'-' AS aggmtransfn,\n"
15465 "'-' AS aggminvtransfn,\n"
15466 "'-' AS aggmfinalfn,\n"
15467 "0 AS aggmtranstype,\n"
15468 "false AS aggfinalextra,\n"
15469 "false AS aggmfinalextra,\n"
15470 "0 AS aggtransspace,\n"
15471 "0 AS aggmtransspace,\n"
15472 "NULL AS aggminitval,\n");
15473
15475 appendPQExpBufferStr(query,
15476 "aggcombinefn,\n"
15477 "aggserialfn,\n"
15478 "aggdeserialfn,\n"
15479 "proparallel,\n");
15480 else
15481 appendPQExpBufferStr(query,
15482 "'-' AS aggcombinefn,\n"
15483 "'-' AS aggserialfn,\n"
15484 "'-' AS aggdeserialfn,\n"
15485 "'u' AS proparallel,\n");
15486
15488 appendPQExpBufferStr(query,
15489 "aggfinalmodify,\n"
15490 "aggmfinalmodify\n");
15491 else
15492 appendPQExpBufferStr(query,
15493 "'0' AS aggfinalmodify,\n"
15494 "'0' AS aggmfinalmodify\n");
15495
15496 appendPQExpBufferStr(query,
15497 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15498 "WHERE a.aggfnoid = p.oid "
15499 "AND p.oid = $1");
15500
15502
15504 }
15505
15506 printfPQExpBuffer(query,
15507 "EXECUTE dumpAgg('%u')",
15508 agginfo->aggfn.dobj.catId.oid);
15509
15511
15514
15536
15537 {
15540
15545 }
15546
15548
15549 /* identify default modify flag for aggkind (must match DefineAggregate) */
15550 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
15551 /* replace omitted flags for old versions */
15556
15557 /* regproc and regtype output is already sufficiently quoted */
15559 aggtransfn, aggtranstype);
15560
15562 {
15564 aggtransspace);
15565 }
15566
15568 {
15571 }
15572
15574 {
15576 aggfinalfn);
15580 {
15582 {
15585 break;
15588 break;
15591 break;
15592 default:
15594 agginfo->aggfn.dobj.name);
15595 break;
15596 }
15597 }
15598 }
15599
15602
15605
15608
15610 {
15612 aggmtransfn,
15613 aggminvtransfn,
15614 aggmtranstype);
15615 }
15616
15618 {
15620 aggmtransspace);
15621 }
15622
15624 {
15627 }
15628
15630 {
15632 aggmfinalfn);
15636 {
15638 {
15641 break;
15644 break;
15647 break;
15648 default:
15650 agginfo->aggfn.dobj.name);
15651 break;
15652 }
15653 }
15654 }
15655
15658 {
15660 aggsortconvop);
15662 }
15663
15666
15668 {
15675 agginfo->aggfn.dobj.name);
15676 }
15677
15680 aggsig);
15681
15685
15689 agginfo->aggfn.dobj.namespace->dobj.name);
15690
15693 agginfo->aggfn.dobj.dumpId,
15696 .owner = agginfo->aggfn.rolname,
15697 .description = "AGGREGATE",
15698 .section = SECTION_PRE_DATA,
15699 .createStmt = q->data,
15700 .dropStmt = delq->data));
15701
15702 /* Dump Aggregate Comments */
15705 agginfo->aggfn.dobj.namespace->dobj.name,
15706 agginfo->aggfn.rolname,
15708
15711 agginfo->aggfn.dobj.namespace->dobj.name,
15712 agginfo->aggfn.rolname,
15714
15715 /*
15716 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
15717 * command look like a function's GRANT; in particular this affects the
15718 * syntax for zero-argument aggregates and ordered-set aggregates.
15719 */
15721
15723
15727 agginfo->aggfn.dobj.namespace->dobj.name,
15729
15733
15734 PQclear(res);
15735
15736 destroyPQExpBuffer(query);
15737 destroyPQExpBuffer(q);
15739 destroyPQExpBuffer(details);
15740}
15741
15742/*
15743 * dumpTSParser
15744 * write out a single text search parser
15745 */
15746static void
15748{
15750 PQExpBuffer q;
15753
15754 /* Do nothing if not dumping schema */
15756 return;
15757
15758 q = createPQExpBuffer();
15760
15762
15765
15777
15780
15784 prsinfo->dobj.namespace->dobj.name);
15785
15789 .namespace = prsinfo->dobj.namespace->dobj.name,
15790 .description = "TEXT SEARCH PARSER",
15791 .section = SECTION_PRE_DATA,
15792 .createStmt = q->data,
15793 .dropStmt = delq->data));
15794
15795 /* Dump Parser Comments */
15800
15801 destroyPQExpBuffer(q);
15804}
15805
15806/*
15807 * dumpTSDictionary
15808 * write out a single text search dictionary
15809 */
15810static void
15812{
15814 PQExpBuffer q;
15816 PQExpBuffer query;
15818 PGresult *res;
15819 char *nspname;
15821
15822 /* Do nothing if not dumping schema */
15824 return;
15825
15826 q = createPQExpBuffer();
15828 query = createPQExpBuffer();
15829
15831
15832 /* Fetch name and namespace of the dictionary's template */
15834 "FROM pg_ts_template p, pg_namespace n "
15835 "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
15836 dictinfo->dicttemplate);
15838 nspname = PQgetvalue(res, 0, 0);
15840
15843
15847
15848 PQclear(res);
15849
15850 /* the dictinitoption can be dumped straight into the command */
15853
15855
15858
15862 dictinfo->dobj.namespace->dobj.name);
15863
15867 .namespace = dictinfo->dobj.namespace->dobj.name,
15868 .owner = dictinfo->rolname,
15869 .description = "TEXT SEARCH DICTIONARY",
15870 .section = SECTION_PRE_DATA,
15871 .createStmt = q->data,
15872 .dropStmt = delq->data));
15873
15874 /* Dump Dictionary Comments */
15879
15880 destroyPQExpBuffer(q);
15882 destroyPQExpBuffer(query);
15884}
15885
15886/*
15887 * dumpTSTemplate
15888 * write out a single text search template
15889 */
15890static void
15892{
15894 PQExpBuffer q;
15897
15898 /* Do nothing if not dumping schema */
15900 return;
15901
15902 q = createPQExpBuffer();
15904
15906
15909
15915
15918
15922 tmplinfo->dobj.namespace->dobj.name);
15923
15927 .namespace = tmplinfo->dobj.namespace->dobj.name,
15928 .description = "TEXT SEARCH TEMPLATE",
15929 .section = SECTION_PRE_DATA,
15930 .createStmt = q->data,
15931 .dropStmt = delq->data));
15932
15933 /* Dump Template Comments */
15938
15939 destroyPQExpBuffer(q);
15942}
15943
15944/*
15945 * dumpTSConfig
15946 * write out a single text search configuration
15947 */
15948static void
15950{
15952 PQExpBuffer q;
15954 PQExpBuffer query;
15956 PGresult *res;
15957 char *nspname;
15959 int ntups,
15960 i;
15963
15964 /* Do nothing if not dumping schema */
15966 return;
15967
15968 q = createPQExpBuffer();
15970 query = createPQExpBuffer();
15971
15973
15974 /* Fetch name and namespace of the config's parser */
15976 "FROM pg_ts_parser p, pg_namespace n "
15977 "WHERE p.oid = '%u' AND n.oid = prsnamespace",
15978 cfginfo->cfgparser);
15980 nspname = PQgetvalue(res, 0, 0);
15982
15985
15988
15989 PQclear(res);
15990
15991 resetPQExpBuffer(query);
15992 appendPQExpBuffer(query,
15993 "SELECT\n"
15994 " ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t\n"
15995 " WHERE t.tokid = m.maptokentype ) AS tokenname,\n"
15996 " m.mapdict::pg_catalog.regdictionary AS dictname\n"
15997 "FROM pg_catalog.pg_ts_config_map AS m\n"
15998 "WHERE m.mapcfg = '%u'\n"
15999 "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
16001
16003 ntups = PQntuples(res);
16004
16007
16009 {
16012
16015 {
16016 /* starting a new token type, so start a new command */
16021 /* tokenname needs quoting, dictname does NOT */
16024 }
16025 else
16027 }
16028
16029 if (ntups > 0)
16031
16032 PQclear(res);
16033
16036
16040 cfginfo->dobj.namespace->dobj.name);
16041
16045 .namespace = cfginfo->dobj.namespace->dobj.name,
16046 .owner = cfginfo->rolname,
16047 .description = "TEXT SEARCH CONFIGURATION",
16048 .section = SECTION_PRE_DATA,
16049 .createStmt = q->data,
16050 .dropStmt = delq->data));
16051
16052 /* Dump Configuration Comments */
16057
16058 destroyPQExpBuffer(q);
16060 destroyPQExpBuffer(query);
16062}
16063
16064/*
16065 * dumpForeignDataWrapper
16066 * write out a single foreign-data wrapper definition
16067 */
16068static void
16070{
16072 PQExpBuffer q;
16075
16076 /* Do nothing if not dumping schema */
16078 return;
16079
16080 q = createPQExpBuffer();
16082
16084
16086 qfdwname);
16087
16090
16093
16096
16098
16100 qfdwname);
16101
16105 NULL);
16106
16110 .owner = fdwinfo->rolname,
16111 .description = "FOREIGN DATA WRAPPER",
16112 .section = SECTION_PRE_DATA,
16113 .createStmt = q->data,
16114 .dropStmt = delq->data));
16115
16116 /* Dump Foreign Data Wrapper Comments */
16121
16122 /* Handle the ACL */
16127
16129
16130 destroyPQExpBuffer(q);
16132}
16133
16134/*
16135 * dumpForeignServer
16136 * write out a foreign server definition
16137 */
16138static void
16140{
16142 PQExpBuffer q;
16144 PQExpBuffer query;
16145 PGresult *res;
16147 char *fdwname;
16148
16149 /* Do nothing if not dumping schema */
16151 return;
16152
16153 q = createPQExpBuffer();
16155 query = createPQExpBuffer();
16156
16158
16159 /* look up the foreign-data wrapper */
16161 "FROM pg_foreign_data_wrapper w "
16162 "WHERE w.oid = '%u'",
16163 srvinfo->srvfdw);
16165 fdwname = PQgetvalue(res, 0, 0);
16166
16169 {
16172 }
16174 {
16177 }
16178
16181
16184
16186
16188 qsrvname);
16189
16193
16197 .owner = srvinfo->rolname,
16198 .description = "SERVER",
16199 .section = SECTION_PRE_DATA,
16200 .createStmt = q->data,
16201 .dropStmt = delq->data));
16202
16203 /* Dump Foreign Server Comments */
16208
16209 /* Handle the ACL */
16214
16215 /* Dump user mappings */
16219 srvinfo->rolname,
16221
16222 PQclear(res);
16223
16225
16226 destroyPQExpBuffer(q);
16228 destroyPQExpBuffer(query);
16229}
16230
16231/*
16232 * dumpUserMappings
16233 *
16234 * This routine is used to dump any user mappings associated with the
16235 * server handed to this routine. Should be called after ArchiveEntry()
16236 * for the server.
16237 */
16238static void
16240 const char *servername, const char *namespace,
16241 const char *owner,
16243{
16244 PQExpBuffer q;
16246 PQExpBuffer query;
16247 PQExpBuffer tag;
16248 PGresult *res;
16249 int ntups;
16253
16254 q = createPQExpBuffer();
16255 tag = createPQExpBuffer();
16257 query = createPQExpBuffer();
16258
16259 /*
16260 * We read from the publicly accessible view pg_user_mappings, so as not
16261 * to fail if run by a non-superuser. Note that the view will show
16262 * umoptions as null if the user hasn't got privileges for the associated
16263 * server; this means that pg_dump will dump such a mapping, but with no
16264 * OPTIONS clause. A possible alternative is to skip such mappings
16265 * altogether, but it's not clear that that's an improvement.
16266 */
16267 appendPQExpBuffer(query,
16268 "SELECT usename, "
16269 "array_to_string(ARRAY("
16270 "SELECT quote_ident(option_name) || ' ' || "
16271 "quote_literal(option_value) "
16272 "FROM pg_options_to_table(umoptions) "
16273 "ORDER BY option_name"
16274 "), E',\n ') AS umoptions "
16275 "FROM pg_user_mappings "
16276 "WHERE srvid = '%u' "
16277 "ORDER BY usename",
16278 catalogId.oid);
16279
16281
16282 ntups = PQntuples(res);
16285
16287 {
16290
16293
16294 resetPQExpBuffer(q);
16297
16300
16302
16306
16307 resetPQExpBuffer(tag);
16309 usename, servername);
16310
16313 .namespace = namespace,
16314 .owner = owner,
16315 .description = "USER MAPPING",
16316 .section = SECTION_PRE_DATA,
16317 .createStmt = q->data,
16318 .dropStmt = delq->data));
16319 }
16320
16321 PQclear(res);
16322
16323 destroyPQExpBuffer(query);
16325 destroyPQExpBuffer(tag);
16326 destroyPQExpBuffer(q);
16327}
16328
16329/*
16330 * Write out default privileges information
16331 */
16332static void
16334{
16336 PQExpBuffer q;
16337 PQExpBuffer tag;
16339
16340 /* Do nothing if not dumping schema, or if we're skipping ACLs */
16342 return;
16343
16344 q = createPQExpBuffer();
16345 tag = createPQExpBuffer();
16346
16348 {
16351 break;
16354 break;
16357 break;
16360 break;
16363 break;
16366 break;
16367 default:
16368 /* shouldn't get here */
16372 }
16373
16375
16376 /* build the actual command(s) for this tuple */
16380 daclinfo->dacl.acl,
16382 daclinfo->defaclrole,
16383 fout->remoteVersion,
16384 q))
16386 daclinfo->dacl.acl);
16387
16391 .namespace = daclinfo->dobj.namespace ?
16393 .owner = daclinfo->defaclrole,
16395 .section = SECTION_POST_DATA,
16396 .createStmt = q->data));
16397
16398 destroyPQExpBuffer(tag);
16399 destroyPQExpBuffer(q);
16400}
16401
16402/*----------
16403 * Write out grant/revoke information
16404 *
16405 * 'objDumpId' is the dump ID of the underlying object.
16406 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
16407 * or InvalidDumpId if there is no need for a second dependency.
16408 * 'type' must be one of
16409 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
16410 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
16411 * 'name' is the formatted name of the object. Must be quoted etc. already.
16412 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
16413 * (Currently we assume that subname is only provided for table columns.)
16414 * 'nspname' is the namespace the object is in (NULL if none).
16415 * 'tag' is the tag to use for the ACL TOC entry; typically, this is NULL
16416 * to use the default for the object type.
16417 * 'owner' is the owner, NULL if there is no owner (for languages).
16418 * 'dacl' is the DumpableAcl struct for the object.
16419 *
16420 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
16421 * no ACL entry was created.
16422 *----------
16423 */
16427 const char *nspname, const char *tag, const char *owner,
16429{
16437 PQExpBuffer sql;
16438
16439 /* Do nothing if ACL dump is not enabled */
16442
16443 /* --data-only skips ACLs *except* large object ACLs */
16446
16447 sql = createPQExpBuffer();
16448
16449 /*
16450 * In binary upgrade mode, we don't run an extension's script but instead
16451 * dump out the objects independently and then recreate them. To preserve
16452 * any initial privileges which were set on extension objects, we need to
16453 * compute the set of GRANT and REVOKE commands necessary to get from the
16454 * default privileges of an object to its initial privileges as recorded
16455 * in pg_init_privs.
16456 *
16457 * At restore time, we apply these commands after having called
16458 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16459 * copy the results into pg_init_privs. This is how we preserve the
16460 * contents of that catalog across binary upgrades.
16461 */
16463 initprivs && *initprivs != '\0')
16464 {
16467 initprivs, acldefault, owner,
16471 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16472 }
16473
16474 /*
16475 * Now figure the GRANT and REVOKE commands needed to get to the object's
16476 * actual current ACL, starting from the initprivs if given, else from the
16477 * object-type-specific default. Also, while buildACLCommands will assume
16478 * that a NULL/empty acls string means it needn't do anything, what that
16479 * actually represents is the object-type-specific default; so we need to
16480 * substitute the acldefault string to get the right results in that case.
16481 */
16482 if (initprivs && *initprivs != '\0')
16483 {
16484 baseacls = initprivs;
16487 }
16488 else
16490
16496
16498 {
16501 int nDeps = 0;
16502
16503 if (tag)
16507 else
16509
16513
16515
16518 .namespace = nspname,
16519 .owner = owner,
16520 .description = "ACL",
16521 .section = SECTION_NONE,
16522 .createStmt = sql->data,
16523 .deps = aclDeps,
16524 .nDeps = nDeps));
16525
16527 }
16528
16529 destroyPQExpBuffer(sql);
16530
16532}
16533
16534/*
16535 * dumpSecLabel
16536 *
16537 * This routine is used to dump any security labels associated with the
16538 * object handed to this routine. The routine takes the object type
16539 * and object name (ready to print, except for schema decoration), plus
16540 * the namespace and owner of the object (for labeling the ArchiveEntry),
16541 * plus catalog ID and subid which are the lookup key for pg_seclabel,
16542 * plus the dump ID for the object (for setting a dependency).
16543 * If a matching pg_seclabel entry is found, it is dumped.
16544 *
16545 * Note: although this routine takes a dumpId for dependency purposes,
16546 * that purpose is just to mark the dependency in the emitted dump file
16547 * for possible future use by pg_restore. We do NOT use it for determining
16548 * ordering of the label in the dump file, because this routine is called
16549 * after dependency sorting occurs. This routine should be called just after
16550 * calling ArchiveEntry() for the specified object.
16551 */
16552static void
16554 const char *namespace, const char *owner,
16556{
16561 PQExpBuffer query;
16562
16563 /* do nothing, if --no-security-labels is supplied */
16565 return;
16566
16567 /*
16568 * Security labels are schema not data ... except large object labels are
16569 * data
16570 */
16572 {
16574 return;
16575 }
16576 else
16577 {
16578 /* We do dump large object security labels in binary-upgrade mode */
16580 return;
16581 }
16582
16583 /* Search for security labels associated with catalogId, using table */
16585
16586 query = createPQExpBuffer();
16587
16589 {
16590 /*
16591 * Ignore label entries for which the subid doesn't match.
16592 */
16594 continue;
16595
16596 appendPQExpBuffer(query,
16597 "SECURITY LABEL FOR %s ON %s ",
16599 if (namespace && *namespace)
16604 }
16605
16607 {
16609
16613 .namespace = namespace,
16614 .owner = owner,
16615 .description = "SECURITY LABEL",
16616 .section = SECTION_NONE,
16617 .createStmt = query->data,
16618 .deps = &dumpId,
16619 .nDeps = 1));
16620 destroyPQExpBuffer(tag);
16621 }
16622
16623 destroyPQExpBuffer(query);
16624}
16625
16626/*
16627 * dumpTableSecLabel
16628 *
16629 * As above, but dump security label for both the specified table (or view)
16630 * and its columns.
16631 */
16632static void
16634{
16639 PQExpBuffer query;
16640 PQExpBuffer target;
16641
16642 /* do nothing, if --no-security-labels is supplied */
16644 return;
16645
16646 /* SecLabel are SCHEMA not data */
16648 return;
16649
16650 /* Search for comments associated with relation, using table */
16652 tbinfo->dobj.catId.oid,
16653 &labels);
16654
16655 /* If security labels exist, build SECURITY LABEL statements */
16657 return;
16658
16659 query = createPQExpBuffer();
16660 target = createPQExpBuffer();
16661
16663 {
16664 const char *colname;
16668
16669 resetPQExpBuffer(target);
16670 if (objsubid == 0)
16671 {
16674 }
16675 else
16676 {
16678 /* first fmtXXX result must be consumed before calling again */
16682 }
16687 }
16689 {
16690 resetPQExpBuffer(target);
16695 .namespace = tbinfo->dobj.namespace->dobj.name,
16696 .owner = tbinfo->rolname,
16697 .description = "SECURITY LABEL",
16698 .section = SECTION_NONE,
16699 .createStmt = query->data,
16700 .deps = &(tbinfo->dobj.dumpId),
16701 .nDeps = 1));
16702 }
16703 destroyPQExpBuffer(query);
16704 destroyPQExpBuffer(target);
16705}
16706
16707/*
16708 * findSecLabels
16709 *
16710 * Find the security label(s), if any, associated with the given object.
16711 * All the objsubid values associated with the given classoid/objoid are
16712 * found with one search.
16713 */
16714static int
16716{
16718 SecLabelItem *low;
16719 SecLabelItem *high;
16720 int nmatch;
16721
16723 {
16725 return 0;
16726 }
16727
16728 /*
16729 * Do binary search to find some item matching the object.
16730 */
16731 low = &seclabels[0];
16733 while (low <= high)
16734 {
16735 middle = low + (high - low) / 2;
16736
16738 high = middle - 1;
16740 low = middle + 1;
16742 high = middle - 1;
16744 low = middle + 1;
16745 else
16746 break; /* found a match */
16747 }
16748
16749 if (low > high) /* no matches */
16750 {
16752 return 0;
16753 }
16754
16755 /*
16756 * Now determine how many items match the object. The search loop
16757 * invariant still holds: only items between low and high inclusive could
16758 * match.
16759 */
16760 nmatch = 1;
16762 {
16764 objoid != middle[-1].objoid)
16765 break;
16766 middle--;
16767 nmatch++;
16768 }
16769
16771
16772 middle += nmatch;
16774 {
16776 objoid != middle->objoid)
16777 break;
16778 middle++;
16779 nmatch++;
16780 }
16781
16782 return nmatch;
16783}
16784
16785/*
16786 * collectSecLabels
16787 *
16788 * Construct a table of all security labels available for database objects;
16789 * also set the has-seclabel component flag for each relevant object.
16790 *
16791 * The table is sorted by classoid/objid/objsubid for speed in lookup.
16792 */
16793static void
16795{
16796 PGresult *res;
16797 PQExpBuffer query;
16803 int ntups;
16805 DumpableObject *dobj;
16806
16807 query = createPQExpBuffer();
16808
16809 appendPQExpBufferStr(query,
16810 "SELECT label, provider, classoid, objoid, objsubid "
16811 "FROM pg_catalog.pg_seclabels "
16812 "ORDER BY classoid, objoid, objsubid");
16813
16815
16816 /* Construct lookup table containing OIDs in numeric form */
16822
16823 ntups = PQntuples(res);
16824
16826 nseclabels = 0;
16827 dobj = NULL;
16828
16830 {
16831 CatalogId objId;
16832 int subid;
16833
16837
16838 /* We needn't remember labels that don't match any dumpable object */
16842 dobj = findObjectByCatalogId(objId);
16844 continue;
16845
16846 /*
16847 * Labels on columns of composite types are linked to the type's
16848 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16849 * in the type's own DumpableObject.
16850 */
16853 {
16855
16859 }
16860 else
16861 dobj->components |= DUMP_COMPONENT_SECLABEL;
16862
16868 nseclabels++;
16869 }
16870
16871 PQclear(res);
16872 destroyPQExpBuffer(query);
16873}
16874
16875/*
16876 * dumpTable
16877 * write out to fout the declarations (not data) of a user-defined table
16878 */
16879static void
16881{
16885
16886 /* Do nothing if not dumping schema */
16888 return;
16889
16891 {
16894 else
16896 }
16897
16898 /* Handle the ACL here */
16901 {
16902 const char *objtype =
16904
16905 tableAclDumpId =
16908 tbinfo->dobj.namespace->dobj.name,
16910 }
16911
16912 /*
16913 * Handle column ACLs, if any. Note: we pull these with a separate query
16914 * rather than trying to fetch them during getTableAttrs, so that we won't
16915 * miss ACLs on system columns. Doing it this way also allows us to dump
16916 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
16917 */
16919 {
16921 PGresult *res;
16923
16925 {
16926 /* Set up query for column ACLs */
16927 appendPQExpBufferStr(query,
16928 "PREPARE getColumnACLs(pg_catalog.oid) AS\n");
16929
16931 {
16932 /*
16933 * In principle we should call acldefault('c', relowner) to
16934 * get the default ACL for a column. However, we don't
16935 * currently store the numeric OID of the relowner in
16936 * TableInfo. We could convert the owner name using regrole,
16937 * but that creates a risk of failure due to concurrent role
16938 * renames. Given that the default ACL for columns is empty
16939 * and is likely to stay that way, it's not worth extra cycles
16940 * and risk to avoid hard-wiring that knowledge here.
16941 */
16942 appendPQExpBufferStr(query,
16943 "SELECT at.attname, "
16944 "at.attacl, "
16945 "'{}' AS acldefault, "
16946 "pip.privtype, pip.initprivs "
16947 "FROM pg_catalog.pg_attribute at "
16948 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
16949 "(at.attrelid = pip.objoid "
16950 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
16951 "AND at.attnum = pip.objsubid) "
16952 "WHERE at.attrelid = $1 AND "
16953 "NOT at.attisdropped "
16954 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
16955 "ORDER BY at.attnum");
16956 }
16957 else
16958 {
16959 appendPQExpBufferStr(query,
16960 "SELECT attname, attacl, '{}' AS acldefault, "
16961 "NULL AS privtype, NULL AS initprivs "
16962 "FROM pg_catalog.pg_attribute "
16963 "WHERE attrelid = $1 AND NOT attisdropped "
16964 "AND attacl IS NOT NULL "
16965 "ORDER BY attnum");
16966 }
16967
16969
16971 }
16972
16973 printfPQExpBuffer(query,
16974 "EXECUTE getColumnACLs('%u')",
16975 tbinfo->dobj.catId.oid);
16976
16978
16980 {
16988
16991 coldacl.privtype = privtype;
16992 coldacl.initprivs = initprivs;
16994
16995 /*
16996 * Column's GRANT type is always TABLE. Each column ACL depends
16997 * on the table-level ACL, since we can restore column ACLs in
16998 * parallel but the table-level ACL has to be done first.
16999 */
17002 tbinfo->dobj.namespace->dobj.name,
17005 }
17006 PQclear(res);
17007 destroyPQExpBuffer(query);
17008 }
17009
17011}
17012
17013/*
17014 * Create the AS clause for a view or materialized view. The semicolon is
17015 * stripped because a materialized view must add a WITH NO DATA clause.
17016 *
17017 * This returns a new buffer which must be freed by the caller.
17018 */
17021{
17024 PGresult *res;
17026
17027 /* Fetch the view definition */
17028 appendPQExpBuffer(query,
17029 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
17030 tbinfo->dobj.catId.oid);
17031
17033
17035 {
17038 tbinfo->dobj.name);
17039 else
17041 tbinfo->dobj.name);
17042 }
17043
17045
17048 tbinfo->dobj.name);
17049
17050 /* Strip off the trailing semicolon so that other things may follow. */
17053
17054 PQclear(res);
17055 destroyPQExpBuffer(query);
17056
17057 return result;
17058}
17059
17060/*
17061 * Create a dummy AS clause for a view. This is used when the real view
17062 * definition has to be postponed because of circular dependencies.
17063 * We must duplicate the view's external properties -- column names and types
17064 * (including collation) -- so that it works for subsequent references.
17065 *
17066 * This returns a new buffer which must be freed by the caller.
17067 */
17070{
17073
17075
17077 {
17081
17083
17084 /*
17085 * Must add collation if not default for the type, because CREATE OR
17086 * REPLACE VIEW won't change it
17087 */
17089 {
17091
17096 }
17097
17099 }
17100
17101 return result;
17102}
17103
17104/*
17105 * dumpTableSchema
17106 * write the declaration (not data) of one user-defined table or view
17107 */
17108static void
17110{
17117 int numParents;
17118 TableInfo **parents;
17123 k;
17124
17125 /* We had better have loaded per-column details about this table */
17127
17130
17133 qrelname);
17134
17137
17138 /* Is it a table or a view? */
17140 {
17141 PQExpBuffer result;
17142
17143 /*
17144 * Note: keep this code in sync with the is_view case in dumpRule()
17145 */
17146
17148
17150
17153 tbinfo->dobj.catId.oid);
17154
17156
17159 else
17160 {
17162 {
17166 }
17168 }
17170 destroyPQExpBuffer(result);
17171
17175 }
17176 else
17177 {
17182
17183 /*
17184 * Set reltypename, and collect any relkind-specific data that we
17185 * didn't fetch during getTables().
17186 */
17188 {
17190 {
17192 PGresult *res;
17193
17195
17196 /* retrieve partition key definition */
17197 appendPQExpBuffer(query,
17198 "SELECT pg_get_partkeydef('%u')",
17199 tbinfo->dobj.catId.oid);
17202 PQclear(res);
17203 destroyPQExpBuffer(query);
17204 break;
17205 }
17207 {
17209 PGresult *res;
17212
17214
17215 /* retrieve name of foreign server and generic options */
17216 appendPQExpBuffer(query,
17217 "SELECT fs.srvname, "
17218 "pg_catalog.array_to_string(ARRAY("
17219 "SELECT pg_catalog.quote_ident(option_name) || "
17220 "' ' || pg_catalog.quote_literal(option_value) "
17221 "FROM pg_catalog.pg_options_to_table(ftoptions) "
17222 "ORDER BY option_name"
17223 "), E',\n ') AS ftoptions "
17224 "FROM pg_catalog.pg_foreign_table ft "
17225 "JOIN pg_catalog.pg_foreign_server fs "
17226 "ON (fs.oid = ft.ftserver) "
17227 "WHERE ft.ftrelid = '%u'",
17228 tbinfo->dobj.catId.oid);
17234 PQclear(res);
17235 destroyPQExpBuffer(query);
17236
17238 break;
17239 }
17242 break;
17243 default:
17245 break;
17246 }
17247
17248 numParents = tbinfo->numParents;
17250
17252
17255 tbinfo->dobj.catId.oid);
17256
17257 /*
17258 * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
17259 * ignore it when dumping if it was set in this case.
17260 */
17264 "UNLOGGED " : "",
17265 reltypename,
17266 qualrelname);
17267
17268 /*
17269 * Attach to type, if reloftype; except in case of a binary upgrade,
17270 * we dump the table normally and attach it to the type afterward.
17271 */
17275 zeroIsError));
17276
17278 {
17279 /* Dump the attributes */
17280 actual_atts = 0;
17282 {
17283 /*
17284 * Normally, dump if it's locally defined in this table, and
17285 * not dropped. But for binary upgrade, we'll dump all the
17286 * columns, and then fix up the dropped and nonlocal cases
17287 * below.
17288 */
17290 {
17293
17294 /*
17295 * Default value --- suppress if to be printed separately
17296 * or not at all.
17297 */
17301
17302 /*
17303 * Not Null constraint --- print it if it is locally
17304 * defined, or if binary upgrade. (In the latter case, we
17305 * reset conislocal below.)
17306 */
17309 dopt->binary_upgrade ||
17310 tbinfo->ispartition));
17311
17312 /*
17313 * Skip column if fully defined by reloftype, except in
17314 * binary upgrade
17315 */
17318 !dopt->binary_upgrade)
17319 continue;
17320
17321 /* Format properly if not first attr */
17324 else
17327 actual_atts++;
17328
17329 /* Attribute name */
17331
17333 {
17334 /*
17335 * ALTER TABLE DROP COLUMN clears
17336 * pg_attribute.atttypid, so we will not have gotten a
17337 * valid type name; insert INTEGER as a stopgap. We'll
17338 * clean things up later.
17339 */
17341 /* and skip to the next column */
17342 continue;
17343 }
17344
17345 /*
17346 * Attribute type; print it except when creating a typed
17347 * table ('OF type_name'), but in binary-upgrade mode,
17348 * print it in that case too.
17349 */
17351 {
17354 }
17355
17357 {
17364 else
17367 }
17368
17370 {
17373 else
17376
17379 }
17380
17381 /* Add collation if not default for the type */
17383 {
17385
17390 }
17391 }
17392
17393 /*
17394 * On the other hand, if we choose not to print a column
17395 * (likely because it is created by inheritance), but the
17396 * column has a locally-defined not-null constraint, we need
17397 * to dump the constraint as a standalone object.
17398 *
17399 * This syntax isn't SQL-conforming, but if you wanted
17400 * standard output you wouldn't be creating non-standard
17401 * objects to begin with.
17402 */
17407 {
17408 /* Format properly if not first attr */
17411 else
17414 actual_atts++;
17415
17419 else
17423 }
17424 }
17425
17426 /*
17427 * Add non-inherited CHECK constraints, if any.
17428 *
17429 * For partitions, we need to include check constraints even if
17430 * they're not defined locally, because the ALTER TABLE ATTACH
17431 * PARTITION that we'll emit later expects the constraint to be
17432 * there. (No need to fix conislocal: ATTACH PARTITION does that)
17433 */
17435 {
17437
17440 continue;
17441
17444 else
17446
17450
17451 actual_atts++;
17452 }
17453
17457 {
17458 /*
17459 * No attributes? we must have a parenthesized attribute list,
17460 * even though empty, when not using the OF TYPE syntax.
17461 */
17463 }
17464
17465 /*
17466 * Emit the INHERITS clause (not for partitions), except in
17467 * binary-upgrade mode.
17468 */
17470 !dopt->binary_upgrade)
17471 {
17473 for (k = 0; k < numParents; k++)
17474 {
17476
17477 if (k > 0)
17480 }
17482 }
17483
17486
17489 }
17490
17493 {
17495
17498 {
17501 }
17503 {
17507 fout);
17508 }
17510 }
17511
17512 /* Dump generic options if any */
17515
17516 /*
17517 * For materialized views, create the AS clause just like a view. At
17518 * this point, we always mark the view as not populated.
17519 */
17521 {
17522 PQExpBuffer result;
17523
17526 result->data);
17527 destroyPQExpBuffer(result);
17528 }
17529 else
17531
17532 /* Materialized views can depend on extensions */
17535 "pg_catalog.pg_class",
17536 "MATERIALIZED VIEW",
17537 qualrelname);
17538
17539 /*
17540 * in binary upgrade mode, update the catalog with any missing values
17541 * that might be present.
17542 */
17544 {
17546 {
17548 {
17550 appendPQExpBufferStr(q,
17551 "SELECT pg_catalog.binary_upgrade_set_missing_value(");
17558 }
17559 }
17560 }
17561
17562 /*
17563 * To create binary-compatible heap files, we have to ensure the same
17564 * physical column order, including dropped columns, as in the
17565 * original. Therefore, we create dropped columns above and drop them
17566 * here, also updating their attlen/attalign values so that the
17567 * dropped column can be skipped properly. (We do not bother with
17568 * restoring the original attbyval setting.) Also, inheritance
17569 * relationships are set up by doing ALTER TABLE INHERIT rather than
17570 * using an INHERITS clause --- the latter would possibly mess up the
17571 * column order. That also means we have to take care about setting
17572 * attislocal correctly, plus fix up any inherited CHECK constraints.
17573 * Analogously, we set up typed tables using ALTER TABLE / OF here.
17574 *
17575 * We process foreign and partitioned tables here, even though they
17576 * lack heap storage, because they can participate in inheritance
17577 * relationships and we want this stuff to be consistent across the
17578 * inheritance tree. We can exclude indexes, toast tables, sequences
17579 * and matviews, even though they have storage, because we don't
17580 * support altering or dropping columns in them, nor can they be part
17581 * of inheritance trees.
17582 */
17587 {
17590
17591 /*
17592 * Drop any dropped columns. Merge the pg_attribute manipulations
17593 * into a single SQL command, so that we don't cause repeated
17594 * relcache flushes on the target table. Otherwise we risk O(N^2)
17595 * relcache bloat while dropping N columns.
17596 */
17597 resetPQExpBuffer(extra);
17600 {
17602 {
17604 {
17606 "UPDATE pg_catalog.pg_attribute\n"
17607 "SET attlen = v.dlen, "
17608 "attalign = v.dalign, "
17609 "attbyval = false\n"
17610 "FROM (VALUES ");
17612 }
17613 else
17620 /* The ALTER ... DROP COLUMN commands must come after */
17625 }
17626 }
17628 {
17630 "WHERE attrelid = ");
17633 " AND attname = v.dname;\n");
17634 /* Now we can issue the actual DROP COLUMN commands */
17636 }
17637
17638 /*
17639 * Fix up inherited columns. As above, do the pg_attribute
17640 * manipulations in a single SQL command.
17641 */
17644 {
17647 {
17649 {
17652 "SET attislocal = false\n"
17653 "WHERE attrelid = ");
17656 " AND attname IN (");
17658 }
17659 else
17662 }
17663 }
17666
17667 /*
17668 * Fix up not-null constraints that come from inheritance. As
17669 * above, do the pg_constraint manipulations in a single SQL
17670 * command. (Actually, two in special cases, if we're doing an
17671 * upgrade from < 18).
17672 */
17675 resetPQExpBuffer(extra);
17677 {
17678 /*
17679 * If a not-null constraint comes from inheritance, reset
17680 * conislocal. The inhcount is fixed by ALTER TABLE INHERIT,
17681 * below. Special hack: in versions < 18, columns with no
17682 * local definition need their constraint to be matched by
17683 * column number in conkeys instead of by constraint name,
17684 * because the latter is not available. (We distinguish the
17685 * case because the constraint name is the empty string.)
17686 */
17689 {
17691 {
17693 {
17695 "SET conislocal = false\n"
17696 "WHERE contype = 'n' AND conrelid = ");
17699 "conname IN (");
17701 }
17702 else
17705 }
17706 else
17707 {
17709 {
17711 "SET conislocal = false\n"
17712 "WHERE contype = 'n' AND conrelid = ");
17715 "conkey IN (");
17717 }
17718 else
17721 }
17722 }
17723 }
17728
17731
17732 /*
17733 * Add inherited CHECK constraints, if any.
17734 *
17735 * For partitions, they were already dumped, and conislocal
17736 * doesn't need fixing.
17737 *
17738 * As above, issue only one direct manipulation of pg_constraint.
17739 * Although it is tempting to merge the ALTER ADD CONSTRAINT
17740 * commands into one as well, refrain for now due to concern about
17741 * possible backend memory bloat if there are many such
17742 * constraints.
17743 */
17744 resetPQExpBuffer(extra);
17747 {
17749
17751 continue;
17752
17758 constr->condef);
17759 /* Update pg_constraint after all the ALTER TABLEs */
17761 {
17763 "SET conislocal = false\n"
17764 "WHERE contype = 'c' AND conrelid = ");
17769 }
17770 else
17773 }
17775 {
17778 }
17779
17781 {
17783 for (k = 0; k < numParents; k++)
17784 {
17786
17788 qualrelname,
17790 }
17791 }
17792
17794 {
17797 qualrelname,
17799 zeroIsError));
17800 }
17801 }
17802
17803 /*
17804 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
17805 * relminmxid of all vacuumable relations. (While vacuum.c processes
17806 * TOAST tables semi-independently, here we see them only as children
17807 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
17808 * child toast table is handled below.)
17809 */
17813 {
17816 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17817 "WHERE oid = ",
17821
17823 {
17824 /*
17825 * The toast table will have the same OID at restore, so we
17826 * can safely target it by OID.
17827 */
17828 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
17830 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17831 "WHERE oid = '%u';\n",
17832 tbinfo->toast_frozenxid,
17834 }
17835 }
17836
17837 /*
17838 * In binary_upgrade mode, restore matviews' populated status by
17839 * poking pg_class directly. This is pretty ugly, but we can't use
17840 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
17841 * matview is not populated even though this matview is; in any case,
17842 * we want to transfer the matview's heap storage, not run REFRESH.
17843 */
17845 tbinfo->relispopulated)
17846 {
17849 "SET relispopulated = 't'\n"
17850 "WHERE oid = ");
17853 }
17854
17855 /*
17856 * Dump additional per-column properties that we can't handle in the
17857 * main CREATE TABLE command.
17858 */
17860 {
17861 /* None of this applies to dropped columns */
17863 continue;
17864
17865 /*
17866 * Dump per-column statistics information. We only issue an ALTER
17867 * TABLE statement if the attstattarget entry for this column is
17868 * not the default value.
17869 */
17875
17876 /*
17877 * Dump per-column storage information. The statement is only
17878 * dumped if the storage has been changed from the type's default.
17879 */
17881 {
17883 {
17886 break;
17889 break;
17892 break;
17895 break;
17896 default:
17898 }
17899
17900 /*
17901 * Only dump the statement if it's a storage type we recognize
17902 */
17907 storage);
17908 }
17909
17910 /*
17911 * Dump per-column compression, if it's been set.
17912 */
17914 {
17916
17918 {
17919 case 'p':
17921 break;
17922 case 'l':
17924 break;
17925 default:
17927 break;
17928 }
17929
17934 cmname);
17935 }
17936
17937 /*
17938 * Dump per-column attributes.
17939 */
17945
17946 /*
17947 * Dump per-column fdw options.
17948 */
17951 appendPQExpBuffer(q,
17952 "ALTER FOREIGN TABLE ONLY %s ALTER COLUMN %s OPTIONS (\n"
17953 " %s\n"
17954 ");\n",
17955 qualrelname,
17958 } /* end loop over columns */
17959
17963 }
17964
17965 /*
17966 * dump properties we only have ALTER TABLE syntax for
17967 */
17972 {
17974 {
17975 /* nothing to do, will be set when the index is dumped */
17976 }
17978 {
17980 qualrelname);
17981 }
17983 {
17985 qualrelname);
17986 }
17987 }
17988
17991 qualrelname);
17992
17996 tbinfo->dobj.namespace->dobj.name);
17997
17999 {
18002
18003 /*
18004 * _selectTablespace() relies on tablespace-enabled objects in the
18005 * default tablespace to have a tablespace of "" (empty string) versus
18006 * non-tablespace-enabled objects to have a tablespace of NULL.
18007 * getTables() sets tbinfo->reltablespace to "" for the default
18008 * tablespace (not NULL).
18009 */
18012
18015 tableam = tbinfo->amname;
18016
18019 .namespace = tbinfo->dobj.namespace->dobj.name,
18020 .tablespace = tablespace,
18021 .tableam = tableam,
18022 .relkind = tbinfo->relkind,
18023 .owner = tbinfo->rolname,
18024 .description = reltypename,
18025 .section = tbinfo->postponed_def ?
18027 .createStmt = q->data,
18029 }
18030
18031 /* Dump Table Comments */
18034
18035 /* Dump Table Security Labels */
18038
18039 /*
18040 * Dump comments for not-null constraints that aren't to be dumped
18041 * separately (those are processed by collectComments/dumpComment).
18042 */
18044 fout->remoteVersion >= 180000)
18045 {
18048
18050 {
18053 {
18055 {
18057 tag = createPQExpBuffer();
18058 }
18059 else
18060 {
18062 resetPQExpBuffer(tag);
18063 }
18064
18069
18072
18075 .namespace = tbinfo->dobj.namespace->dobj.name,
18076 .owner = tbinfo->rolname,
18077 .description = "COMMENT",
18078 .section = SECTION_NONE,
18079 .createStmt = comment->data,
18080 .deps = &(tbinfo->dobj.dumpId),
18081 .nDeps = 1));
18082 }
18083 }
18084
18086 destroyPQExpBuffer(tag);
18087 }
18088
18089 /* Dump comments on inlined table constraints */
18091 {
18093
18095 continue;
18096
18099 }
18100
18101 destroyPQExpBuffer(q);
18103 destroyPQExpBuffer(extra);
18106}
18107
18108/*
18109 * dumpTableAttach
18110 * write to fout the commands to attach a child partition
18111 *
18112 * Child partitions are always made by creating them separately
18113 * and then using ATTACH PARTITION, rather than using
18114 * CREATE TABLE ... PARTITION OF. This is important for preserving
18115 * any possible discrepancy in column layout, to allow assigning the
18116 * correct tablespace if different, and so that it's possible to restore
18117 * a partition without restoring its parent. (You'll get an error from
18118 * the ATTACH PARTITION command, but that can be ignored, or skipped
18119 * using "pg_restore -L" if you prefer.) The last point motivates
18120 * treating ATTACH PARTITION as a completely separate ArchiveEntry
18121 * rather than emitting it within the child partition's ArchiveEntry.
18122 */
18123static void
18125{
18127 PQExpBuffer q;
18128 PGresult *res;
18129 char *partbound;
18130
18131 /* Do nothing if not dumping schema */
18133 return;
18134
18135 q = createPQExpBuffer();
18136
18138 {
18139 /* Set up query for partbound details */
18140 appendPQExpBufferStr(q,
18141 "PREPARE dumpTableAttach(pg_catalog.oid) AS\n");
18142
18143 appendPQExpBufferStr(q,
18144 "SELECT pg_get_expr(c.relpartbound, c.oid) "
18145 "FROM pg_class c "
18146 "WHERE c.oid = $1");
18147
18149
18151 }
18152
18153 printfPQExpBuffer(q,
18154 "EXECUTE dumpTableAttach('%u')",
18155 attachinfo->partitionTbl->dobj.catId.oid);
18156
18158 partbound = PQgetvalue(res, 0, 0);
18159
18160 /* Perform ALTER TABLE on the parent */
18161 printfPQExpBuffer(q,
18162 "ALTER TABLE ONLY %s ",
18164 appendPQExpBuffer(q,
18165 "ATTACH PARTITION %s %s;\n",
18167 partbound);
18168
18169 /*
18170 * There is no point in creating a drop query as the drop is done by table
18171 * drop. (If you think to change this, see also _printTocEntry().)
18172 * Although this object doesn't really have ownership as such, set the
18173 * owner field anyway to ensure that the command is run by the correct
18174 * role at restore time.
18175 */
18178 .namespace = attachinfo->dobj.namespace->dobj.name,
18179 .owner = attachinfo->partitionTbl->rolname,
18180 .description = "TABLE ATTACH",
18181 .section = SECTION_PRE_DATA,
18182 .createStmt = q->data));
18183
18184 PQclear(res);
18185 destroyPQExpBuffer(q);
18186}
18187
18188/*
18189 * dumpAttrDef --- dump an attribute's default-value declaration
18190 */
18191static void
18193{
18197 PQExpBuffer q;
18200 char *tag;
18202
18203 /* Do nothing if not dumping schema */
18205 return;
18206
18207 /* Skip if not "separate"; it was dumped in the table's definition */
18209 return;
18210
18211 q = createPQExpBuffer();
18213
18215
18217
18218 appendPQExpBuffer(q,
18219 "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
18221 adinfo->adef_expr);
18222
18226
18228
18231 ARCHIVE_OPTS(.tag = tag,
18233 .owner = tbinfo->rolname,
18234 .description = "DEFAULT",
18235 .section = SECTION_PRE_DATA,
18236 .createStmt = q->data,
18237 .dropStmt = delq->data));
18238
18239 free(tag);
18240 destroyPQExpBuffer(q);
18243}
18244
18245/*
18246 * getAttrName: extract the correct name for an attribute
18247 *
18248 * The array tblInfo->attnames[] only provides names of user attributes;
18249 * if a system attribute number is supplied, we have to fake it.
18250 * We also do a little bit of bounds checking for safety's sake.
18251 */
18252static const char *
18254{
18257 switch (attrnum)
18258 {
18260 return "ctid";
18262 return "xmin";
18264 return "cmin";
18266 return "xmax";
18268 return "cmax";
18270 return "tableoid";
18271 }
18273 attrnum, tblInfo->dobj.name);
18275}
18276
18277/*
18278 * dumpIndex
18279 * write out to fout a user-defined index
18280 */
18281static void
18283{
18287 PQExpBuffer q;
18291
18292 /* Do nothing if not dumping schema */
18294 return;
18295
18296 q = createPQExpBuffer();
18298
18301
18302 /*
18303 * If there's an associated constraint, don't dump the index per se, but
18304 * do dump any comment for it. (This is safe because dependency ordering
18305 * will have ensured the constraint is emitted first.) Note that the
18306 * emitted comment has to be shown as depending on the constraint, not the
18307 * index, in such cases.
18308 */
18310 {
18317
18320 indxinfo->dobj.catId.oid);
18321
18322 /* Plain secondary index */
18324
18325 /*
18326 * Append ALTER TABLE commands as needed to set properties that we
18327 * only have ALTER TABLE syntax for. Keep this in sync with the
18328 * similar code in dumpConstraint!
18329 */
18330
18331 /* If the index is clustered, we need to record that. */
18333 {
18336 /* index name is not qualified in this syntax */
18338 qindxname);
18339 }
18340
18341 /*
18342 * If the index has any statistics on some of its columns, generate
18343 * the associated ALTER INDEX queries.
18344 */
18346 {
18348
18355
18357 {
18359
18360 /*
18361 * Note that this is a column number, so no quotes should be
18362 * used.
18363 */
18368 }
18369 }
18370
18371 /* Indexes can depend on extensions */
18373 "pg_catalog.pg_class",
18375
18376 /* If the index defines identity, we need to record that. */
18378 {
18381 /* index name is not qualified in this syntax */
18383 qindxname);
18384 }
18385
18386 /*
18387 * If this index is a member of a partitioned index, the backend will
18388 * not allow us to drop it separately, so don't try. It will go away
18389 * automatically when we drop either the index's table or the
18390 * partitioned index. (If, in a selective restore with --clean, we
18391 * drop neither of those, then this index will not be dropped either.
18392 * But that's fine, and even if you think it's not, the backend won't
18393 * let us do differently.)
18394 */
18397
18401 .namespace = tbinfo->dobj.namespace->dobj.name,
18402 .tablespace = indxinfo->tablespace,
18403 .owner = tbinfo->rolname,
18404 .description = "INDEX",
18405 .section = SECTION_POST_DATA,
18406 .createStmt = q->data,
18407 .dropStmt = delq->data));
18408
18411 }
18412
18413 /* Dump Index Comments */
18416 tbinfo->dobj.namespace->dobj.name,
18417 tbinfo->rolname,
18418 indxinfo->dobj.catId, 0,
18420 indxinfo->dobj.dumpId);
18421
18422 destroyPQExpBuffer(q);
18426}
18427
18428/*
18429 * dumpIndexAttach
18430 * write out to fout a partitioned-index attachment clause
18431 */
18432static void
18434{
18435 /* Do nothing if not dumping schema */
18437 return;
18438
18440 {
18442
18447
18448 /*
18449 * There is no need for a dropStmt since the drop is done implicitly
18450 * when we drop either the index's table or the partitioned index.
18451 * Moreover, since there's no ALTER INDEX DETACH PARTITION command,
18452 * there's no way to do it anyway. (If you think to change this,
18453 * consider also what to do with --if-exists.)
18454 *
18455 * Although this object doesn't really have ownership as such, set the
18456 * owner field anyway to ensure that the command is run by the correct
18457 * role at restore time.
18458 */
18461 .namespace = attachinfo->dobj.namespace->dobj.name,
18462 .owner = attachinfo->parentIdx->indextable->rolname,
18463 .description = "INDEX ATTACH",
18464 .section = SECTION_POST_DATA,
18465 .createStmt = q->data));
18466
18467 destroyPQExpBuffer(q);
18468 }
18469}
18470
18471/*
18472 * dumpStatisticsExt
18473 * write out to fout an extended statistics object
18474 */
18475static void
18477{
18479 PQExpBuffer q;
18481 PQExpBuffer query;
18483 PGresult *res;
18485
18486 /* Do nothing if not dumping schema */
18488 return;
18489
18490 q = createPQExpBuffer();
18492 query = createPQExpBuffer();
18493
18495
18497 "pg_catalog.pg_get_statisticsobjdef('%u'::pg_catalog.oid)",
18498 statsextinfo->dobj.catId.oid);
18499
18501
18503
18504 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
18506
18507 /*
18508 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
18509 * for this statistics object is not the default value.
18510 */
18512 {
18516 statsextinfo->stattarget);
18517 }
18518
18521
18524 statsextinfo->dobj.dumpId,
18526 .namespace = statsextinfo->dobj.namespace->dobj.name,
18527 .owner = statsextinfo->rolname,
18528 .description = "STATISTICS",
18529 .section = SECTION_POST_DATA,
18530 .createStmt = q->data,
18531 .dropStmt = delq->data));
18532
18533 /* Dump Statistics Comments */
18536 statsextinfo->dobj.namespace->dobj.name,
18537 statsextinfo->rolname,
18538 statsextinfo->dobj.catId, 0,
18539 statsextinfo->dobj.dumpId);
18540
18541 PQclear(res);
18542 destroyPQExpBuffer(q);
18544 destroyPQExpBuffer(query);
18546}
18547
18548/*
18549 * dumpStatisticsExtStats
18550 * write out to fout the stats for an extended statistics object
18551 */
18552static void
18554{
18556 PQExpBuffer query;
18557 PGresult *res;
18558 int nstats;
18559
18560 /* Do nothing if not dumping statistics */
18562 return;
18563
18565 {
18567
18568 /*---------
18569 * Set up query for details about extended statistics objects.
18570 *
18571 * The query depends on the backend version:
18572 * - In v19 and newer versions, query directly the pg_stats_ext*
18573 * catalogs.
18574 * - In v18 and older versions, ndistinct and dependencies have a
18575 * different format that needs translation.
18576 * - In v14 and older versions, inherited does not exist.
18577 * - In v11 and older versions, there is no pg_stats_ext, hence
18578 * the logic joins pg_statistic_ext and pg_namespace.
18579 *---------
18580 */
18581
18583 "PREPARE getExtStatsStats(pg_catalog.name, pg_catalog.name) AS\n"
18584 "SELECT ");
18585
18586 /*
18587 * Versions 15 and newer have inherited stats.
18588 *
18589 * Create this column in all versions because we need to order by it
18590 * later.
18591 */
18594 else
18596
18597 /*--------
18598 * The ndistinct and dependencies formats changed in v19, so
18599 * everything before that needs to be translated.
18600 *
18601 * The ndistinct translation converts this kind of data:
18602 * {"3, 4": 11, "3, 6": 11, "4, 6": 11, "3, 4, 6": 11}
18603 *
18604 * to this:
18605 * [ {"attributes": [3,4], "ndistinct": 11},
18606 * {"attributes": [3,6], "ndistinct": 11},
18607 * {"attributes": [4,6], "ndistinct": 11},
18608 * {"attributes": [3,4,6], "ndistinct": 11} ]
18609 *
18610 * The dependencies translation converts this kind of data:
18611 * {"3 => 4": 1.000000, "3 => 6": 1.000000,
18612 * "4 => 6": 1.000000, "3, 4 => 6": 1.000000,
18613 * "3, 6 => 4": 1.000000}
18614 *
18615 * to this:
18616 * [ {"attributes": [3], "dependency": 4, "degree": 1.000000},
18617 * {"attributes": [3], "dependency": 6, "degree": 1.000000},
18618 * {"attributes": [4], "dependency": 6, "degree": 1.000000},
18619 * {"attributes": [3,4], "dependency": 6, "degree": 1.000000},
18620 * {"attributes": [3,6], "dependency": 4, "degree": 1.000000} ]
18621 *--------
18622 */
18625 else
18627 "( "
18628 "SELECT json_agg( "
18629 " json_build_object( "
18631 " string_to_array(kv.key, ', ')::integer[], "
18633 " kv.value::bigint )) "
18634 "FROM json_each_text(e.n_distinct::text::json) AS kv"
18635 ") AS n_distinct, "
18636 "( "
18637 "SELECT json_agg( "
18638 " json_build_object( "
18640 " string_to_array( "
18641 " split_part(kv.key, ' => ', 1), "
18642 " ', ')::integer[], "
18644 " split_part(kv.key, ' => ', 2)::integer, "
18646 " kv.value::double precision )) "
18647 "FROM json_each_text(e.dependencies::text::json) AS kv "
18648 ") AS dependencies ");
18649
18650 /* pg_stats_ext introduced in v12 */
18653 "FROM pg_catalog.pg_stats_ext AS e "
18654 "WHERE e.statistics_schemaname = $1 "
18655 "AND e.statistics_name = $2 ");
18656 else
18658 "FROM ( "
18659 "SELECT s.stxndistinct AS n_distinct, "
18660 " s.stxdependencies AS dependencies "
18661 "FROM pg_catalog.pg_statistic_ext AS s "
18662 "JOIN pg_catalog.pg_namespace AS n "
18663 "ON n.oid = s.stxnamespace "
18664 "WHERE n.nspname = $1 "
18665 "AND s.stxname = $2 "
18666 ") AS e ");
18667
18668 /* we always have an inherited column, but it may be a constant */
18670
18672
18674
18676 }
18677
18678 query = createPQExpBuffer();
18679
18685
18687
18688 destroyPQExpBuffer(query);
18689
18690 nstats = PQntuples(res);
18691
18692 if (nstats > 0)
18693 {
18695
18699
18701 {
18703
18706
18707 appendPQExpBufferStr(out,
18708 "SELECT * FROM pg_catalog.pg_restore_extended_stats(\n");
18710 fout->remoteVersion);
18711
18712 /* Relation information */
18717
18718 /* Extended statistics information */
18725
18729
18733
18735 }
18736
18739 .namespace = statsextinfo->dobj.namespace->dobj.name,
18740 .owner = statsextinfo->rolname,
18741 .description = "EXTENDED STATISTICS DATA",
18742 .section = SECTION_POST_DATA,
18743 .createStmt = out->data,
18744 .deps = &statsextinfo->dobj.dumpId,
18745 .nDeps = 1));
18746 destroyPQExpBuffer(out);
18747 }
18748 PQclear(res);
18749}
18750
18751/*
18752 * dumpConstraint
18753 * write out to fout a user-defined constraint
18754 */
18755static void
18757{
18760 PQExpBuffer q;
18764
18765 /* Do nothing if not dumping schema */
18767 return;
18768
18769 q = createPQExpBuffer();
18771
18774
18778 {
18779 /* Index-related constraint */
18781 int k;
18782
18784
18787 coninfo->dobj.name);
18788
18791 indxinfo->dobj.catId.oid);
18792
18797
18799 {
18800 /* pg_get_constraintdef should have provided everything */
18802 }
18803 else
18804 {
18805 appendPQExpBufferStr(q,
18807
18808 /*
18809 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
18810 * indexes. Being able to create this was fixed, but we need to
18811 * make the index distinct in order to be able to restore the
18812 * dump.
18813 */
18818 {
18821
18823 break;
18825
18827 (k == 0) ? "" : ", ",
18829 }
18832
18835
18837 {
18840
18842 break;
18844
18848 }
18849
18851
18853 {
18857 }
18858
18860 {
18864 }
18865
18867 }
18868
18869 /*
18870 * Append ALTER TABLE commands as needed to set properties that we
18871 * only have ALTER TABLE syntax for. Keep this in sync with the
18872 * similar code in dumpIndex!
18873 */
18874
18875 /* If the index is clustered, we need to record that. */
18877 {
18880 /* index name is not qualified in this syntax */
18883 }
18884
18885 /* If the index defines identity, we need to record that. */
18887 {
18890 /* index name is not qualified in this syntax */
18893 }
18894
18895 /* Indexes can depend on extensions */
18897 "pg_catalog.pg_class", "INDEX",
18899
18904
18906
18909 ARCHIVE_OPTS(.tag = tag,
18911 .tablespace = indxinfo->tablespace,
18912 .owner = tbinfo->rolname,
18913 .description = "CONSTRAINT",
18914 .section = SECTION_POST_DATA,
18915 .createStmt = q->data,
18916 .dropStmt = delq->data));
18917 }
18919 {
18921
18922 /*
18923 * Foreign keys on partitioned tables are always declared as
18924 * inheriting to partitions; for all other cases, emit them as
18925 * applying ONLY directly to the named table, because that's how they
18926 * work for regular inherited tables.
18927 */
18929
18930 /*
18931 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
18932 * current table data is not processed
18933 */
18938 coninfo->condef);
18939
18944
18946
18949 ARCHIVE_OPTS(.tag = tag,
18951 .owner = tbinfo->rolname,
18952 .description = "FK CONSTRAINT",
18953 .section = SECTION_POST_DATA,
18954 .createStmt = q->data,
18955 .dropStmt = delq->data));
18956 }
18958 {
18959 /* CHECK or invalid not-null constraint on a table */
18960
18961 /* Ignore if not to be dumped separately, or if it was inherited */
18963 {
18964 const char *keyword;
18965
18967 keyword = "CHECK CONSTRAINT";
18968 else
18969 keyword = "CONSTRAINT";
18970
18971 /* not ONLY since we want it to propagate to children */
18976 coninfo->condef);
18977
18982
18984
18987 ARCHIVE_OPTS(.tag = tag,
18989 .owner = tbinfo->rolname,
18990 .description = keyword,
18991 .section = SECTION_POST_DATA,
18992 .createStmt = q->data,
18993 .dropStmt = delq->data));
18994 }
18995 }
18997 {
18998 /* CHECK, NOT NULL constraint on a domain */
19000
19002
19003 /* Ignore if not to be dumped separately */
19005 {
19006 const char *keyword;
19007
19009 keyword = "CHECK CONSTRAINT";
19010 else
19011 keyword = "CONSTRAINT";
19012
19017 coninfo->condef);
19018
19023
19025
19028 ARCHIVE_OPTS(.tag = tag,
19030 .owner = tyinfo->rolname,
19031 .description = keyword,
19032 .section = SECTION_POST_DATA,
19033 .createStmt = q->data,
19034 .dropStmt = delq->data));
19035
19037 {
19040
19043
19045 tyinfo->dobj.namespace->dobj.name,
19046 tyinfo->rolname,
19050 }
19051 }
19052 }
19053 else
19054 {
19056 coninfo->contype);
19057 }
19058
19059 /* Dump Constraint Comments --- only works for table constraints */
19063
19064 free(tag);
19065 destroyPQExpBuffer(q);
19067}
19068
19069/*
19070 * dumpTableConstraintComment --- dump a constraint's comment if any
19071 *
19072 * This is split out because we need the function in two different places
19073 * depending on whether the constraint is dumped as part of CREATE TABLE
19074 * or as a separate ALTER command.
19075 */
19076static void
19078{
19082
19084
19087
19090 tbinfo->dobj.namespace->dobj.name,
19091 tbinfo->rolname,
19092 coninfo->dobj.catId, 0,
19094
19097}
19098
19101{
19103 {
19106 }
19107
19110}
19111
19112/*
19113 * bsearch() comparator for SequenceItem
19114 */
19115static int
19117{
19120
19122}
19123
19124/*
19125 * collectSequences
19126 *
19127 * Construct a table of sequence information. This table is sorted by OID for
19128 * speed in lookup.
19129 */
19130static void
19132{
19133 PGresult *res;
19134 const char *query;
19135
19136 /*
19137 * Before Postgres 10, sequence metadata is in the sequence itself. With
19138 * some extra effort, we might be able to use the sorted table for those
19139 * versions, but for now it seems unlikely to be worth it.
19140 *
19141 * Since version 18, we can gather the sequence data in this query with
19142 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19143 */
19145 return;
19148 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19149 "seqstart, seqincrement, "
19150 "seqmax, seqmin, "
19151 "seqcache, seqcycle, "
19152 "NULL, 'f' "
19153 "FROM pg_catalog.pg_sequence "
19154 "ORDER BY seqrelid";
19155 else
19156 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19157 "seqstart, seqincrement, "
19158 "seqmax, seqmin, "
19159 "seqcache, seqcycle, "
19160 "last_value, is_called "
19161 "FROM pg_catalog.pg_sequence, "
19162 "pg_get_sequence_data(seqrelid) "
19163 "ORDER BY seqrelid;";
19164
19166
19169
19171 {
19183 }
19184
19185 PQclear(res);
19186}
19187
19188/*
19189 * dumpSequence
19190 * write the declaration (not data) of one user-defined sequence
19191 */
19192static void
19194{
19199 default_maxv;
19204
19206
19207 /*
19208 * For versions >= 10, the sequence information is gathered in a sorted
19209 * table before any calls to dumpSequence(). See collectSequences() for
19210 * more information.
19211 */
19213 {
19215
19217
19221 }
19222 else
19223 {
19224 PGresult *res;
19225
19226 /*
19227 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
19228 *
19229 * Note: it might seem that 'bigint' potentially needs to be
19230 * schema-qualified, but actually that's a keyword.
19231 */
19232 appendPQExpBuffer(query,
19233 "SELECT 'bigint' AS sequence_type, "
19234 "start_value, increment_by, max_value, min_value, "
19235 "cache_value, is_cycled FROM %s",
19237
19239
19242 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19243 PQntuples(res)),
19245
19254
19255 PQclear(res);
19256 }
19257
19258 /* Calculate default limits for a sequence of this type */
19261 {
19264 }
19266 {
19269 }
19271 {
19274 }
19275 else
19276 {
19279 }
19280
19281 /*
19282 * Identity sequences are not to be dropped separately.
19283 */
19285 {
19288 }
19289
19290 resetPQExpBuffer(query);
19291
19293 {
19295 tbinfo->dobj.catId.oid);
19296
19297 /*
19298 * In older PG versions a sequence will have a pg_type entry, but v14
19299 * and up don't use that, so don't attempt to preserve the type OID.
19300 */
19301 }
19302
19304 {
19306
19307 appendPQExpBuffer(query,
19308 "ALTER TABLE %s ",
19309 fmtQualifiedDumpable(owning_tab));
19310 appendPQExpBuffer(query,
19311 "ALTER COLUMN %s ADD GENERATED ",
19319
19320 /*
19321 * Emit persistence option only if it's different from the owning
19322 * table's. This avoids using this new syntax unnecessarily.
19323 */
19327 "UNLOGGED" : "LOGGED");
19328 }
19329 else
19330 {
19331 appendPQExpBuffer(query,
19332 "CREATE %sSEQUENCE %s\n",
19334 "UNLOGGED " : "",
19336
19339 }
19340
19342
19344
19347 else
19349
19352 else
19354
19355 appendPQExpBuffer(query,
19358
19361 else
19363
19364 /* binary_upgrade: no need to clear TOAST table oid */
19365
19369 tbinfo->dobj.namespace->dobj.name);
19370
19374 .namespace = tbinfo->dobj.namespace->dobj.name,
19375 .owner = tbinfo->rolname,
19376 .description = "SEQUENCE",
19377 .section = SECTION_PRE_DATA,
19378 .createStmt = query->data,
19379 .dropStmt = delqry->data));
19380
19381 /*
19382 * If the sequence is owned by a table column, emit the ALTER for it as a
19383 * separate TOC entry immediately following the sequence's own entry. It's
19384 * OK to do this rather than using full sorting logic, because the
19385 * dependency that tells us it's owned will have forced the table to be
19386 * created first. We can't just include the ALTER in the TOC entry
19387 * because it will fail if we haven't reassigned the sequence owner to
19388 * match the table's owner.
19389 *
19390 * We need not schema-qualify the table reference because both sequence
19391 * and table must be in the same schema.
19392 */
19394 {
19396
19400
19402 {
19403 resetPQExpBuffer(query);
19407 fmtQualifiedDumpable(owning_tab));
19410
19414 .namespace = tbinfo->dobj.namespace->dobj.name,
19415 .owner = tbinfo->rolname,
19416 .description = "SEQUENCE OWNED BY",
19417 .section = SECTION_PRE_DATA,
19418 .createStmt = query->data,
19419 .deps = &(tbinfo->dobj.dumpId),
19420 .nDeps = 1));
19421 }
19422 }
19423
19424 /* Dump Sequence Comments and Security Labels */
19429
19434
19437 destroyPQExpBuffer(query);
19440}
19441
19442/*
19443 * dumpSequenceData
19444 * write the data of one user-defined sequence
19445 */
19446static void
19448{
19450 int64 last;
19452 PQExpBuffer query;
19453
19454 /* needn't bother if not dumping sequence data */
19456 return;
19457
19458 query = createPQExpBuffer();
19459
19460 /*
19461 * For versions >= 18, the sequence information is gathered in the sorted
19462 * array before any calls to dumpSequenceData(). See collectSequences()
19463 * for more information.
19464 *
19465 * For older versions, we have to query the sequence relations
19466 * individually.
19467 */
19469 {
19470 PGresult *res;
19471
19472 appendPQExpBuffer(query,
19473 "SELECT last_value, is_called FROM %s",
19475
19477
19480 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19481 PQntuples(res)),
19483
19486
19487 PQclear(res);
19488 }
19489 else
19490 {
19492 SequenceItem *entry;
19493
19496
19500
19503 "SELECT privilege on the sequence or the sequence may "
19504 "have been concurrently dropped",
19505 tbinfo->dobj.name);
19506
19507 last = entry->last_value;
19509 }
19510
19511 resetPQExpBuffer(query);
19516
19520 .namespace = tbinfo->dobj.namespace->dobj.name,
19521 .owner = tbinfo->rolname,
19522 .description = "SEQUENCE SET",
19523 .section = SECTION_DATA,
19524 .createStmt = query->data,
19525 .deps = &(tbinfo->dobj.dumpId),
19526 .nDeps = 1));
19527
19528 destroyPQExpBuffer(query);
19529}
19530
19531/*
19532 * dumpTrigger
19533 * write the declaration of one user-defined table trigger
19534 */
19535static void
19537{
19540 PQExpBuffer query;
19545 char *tag;
19546
19547 /* Do nothing if not dumping schema */
19549 return;
19550
19551 query = createPQExpBuffer();
19555
19557
19560
19563
19564 /* Triggers can depend on extensions */
19566 "pg_catalog.pg_trigger", "TRIGGER",
19567 trigidentity->data);
19568
19570 {
19572
19573 /*
19574 * Partition triggers only appear here because their 'tgenabled' flag
19575 * differs from its parent's. The trigger is created already, so
19576 * remove the CREATE and replace it with an ALTER. (Clear out the
19577 * DROP query too, so that pg_dump --create does not cause errors.)
19578 */
19579 resetPQExpBuffer(query);
19585 {
19586 case 'f':
19587 case 'D':
19589 break;
19590 case 't':
19591 case 'O':
19593 break;
19594 case 'R':
19596 break;
19597 case 'A':
19599 break;
19600 }
19603 }
19605 {
19610 {
19611 case 'D':
19612 case 'f':
19614 break;
19615 case 'A':
19617 break;
19618 case 'R':
19620 break;
19621 default:
19623 break;
19624 }
19627 }
19628
19631
19633
19636 ARCHIVE_OPTS(.tag = tag,
19638 .owner = tbinfo->rolname,
19639 .description = "TRIGGER",
19640 .section = SECTION_POST_DATA,
19641 .createStmt = query->data,
19642 .dropStmt = delqry->data));
19643
19648
19649 free(tag);
19650 destroyPQExpBuffer(query);
19655}
19656
19657/*
19658 * dumpEventTrigger
19659 * write the declaration of one user-defined event trigger
19660 */
19661static void
19663{
19665 PQExpBuffer query;
19668
19669 /* Do nothing if not dumping schema */
19671 return;
19672
19673 query = createPQExpBuffer();
19675
19677
19682
19684 {
19688 }
19689
19693
19695 {
19697 qevtname);
19699 {
19700 case 'D':
19702 break;
19703 case 'A':
19705 break;
19706 case 'R':
19708 break;
19709 default:
19711 break;
19712 }
19714 }
19715
19717 qevtname);
19718
19722
19726 .owner = evtinfo->evtowner,
19727 .description = "EVENT TRIGGER",
19728 .section = SECTION_POST_DATA,
19729 .createStmt = query->data,
19730 .dropStmt = delqry->data));
19731
19736
19741
19742 destroyPQExpBuffer(query);
19745}
19746
19747/*
19748 * dumpRule
19749 * Dump a rule
19750 */
19751static void
19753{
19757 PQExpBuffer query;
19758 PQExpBuffer cmd;
19762 PGresult *res;
19763 char *tag;
19764
19765 /* Do nothing if not dumping schema */
19767 return;
19768
19769 /*
19770 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
19771 * we do not want to dump it as a separate object.
19772 */
19774 return;
19775
19776 /*
19777 * If it's an ON SELECT rule, we want to print it as a view definition,
19778 * instead of a rule.
19779 */
19781
19782 query = createPQExpBuffer();
19783 cmd = createPQExpBuffer();
19786
19788
19790 {
19791 PQExpBuffer result;
19792
19793 /*
19794 * We need OR REPLACE here because we'll be replacing a dummy view.
19795 * Otherwise this should look largely like the regular view dump code.
19796 */
19800 {
19804 }
19807 destroyPQExpBuffer(result);
19810 tbinfo->checkoption);
19812 }
19813 else
19814 {
19815 /* In the rule case, just print pg_get_ruledef's result verbatim */
19816 appendPQExpBuffer(query,
19817 "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid)",
19819
19821
19825
19827
19828 PQclear(res);
19829 }
19830
19831 /*
19832 * Add the command to alter the rules replication firing semantics if it
19833 * differs from the default.
19834 */
19836 {
19839 {
19840 case 'A':
19843 break;
19844 case 'R':
19847 break;
19848 case 'D':
19851 break;
19852 }
19853 }
19854
19856 {
19857 /*
19858 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
19859 * REPLACE VIEW to replace the rule with something with minimal
19860 * dependencies.
19861 */
19862 PQExpBuffer result;
19863
19868 destroyPQExpBuffer(result);
19869 }
19870 else
19871 {
19876 }
19877
19880
19882
19885 ARCHIVE_OPTS(.tag = tag,
19887 .owner = tbinfo->rolname,
19888 .description = "RULE",
19889 .section = SECTION_POST_DATA,
19890 .createStmt = cmd->data,
19891 .dropStmt = delcmd->data));
19892
19893 /* Dump rule comments */
19896 tbinfo->dobj.namespace->dobj.name,
19897 tbinfo->rolname,
19899
19900 free(tag);
19901 destroyPQExpBuffer(query);
19902 destroyPQExpBuffer(cmd);
19906}
19907
19908/*
19909 * getExtensionMembership --- obtain extension membership data
19910 *
19911 * We need to identify objects that are extension members as soon as they're
19912 * loaded, so that we can correctly determine whether they need to be dumped.
19913 * Generally speaking, extension member objects will get marked as *not* to
19914 * be dumped, as they will be recreated by the single CREATE EXTENSION
19915 * command. However, in binary upgrade mode we still need to dump the members
19916 * individually.
19917 */
19918void
19921{
19922 PQExpBuffer query;
19923 PGresult *res;
19924 int ntups,
19925 i;
19927 i_objid,
19928 i_refobjid;
19929 ExtensionInfo *ext;
19930
19931 /* Nothing to do if no extensions */
19933 return;
19934
19935 query = createPQExpBuffer();
19936
19937 /* refclassid constraint is redundant but may speed the search */
19939 "classid, objid, refobjid "
19940 "FROM pg_depend "
19941 "WHERE refclassid = 'pg_extension'::regclass "
19942 "AND deptype = 'e' "
19943 "ORDER BY 3");
19944
19946
19947 ntups = PQntuples(res);
19948
19952
19953 /*
19954 * Since we ordered the SELECT by referenced ID, we can expect that
19955 * multiple entries for the same extension will appear together; this
19956 * saves on searches.
19957 */
19958 ext = NULL;
19959
19961 {
19962 CatalogId objId;
19964
19968
19972
19974 {
19975 /* shouldn't happen */
19977 continue;
19978 }
19979
19980 recordExtensionMembership(objId, ext);
19981 }
19982
19983 PQclear(res);
19984
19985 destroyPQExpBuffer(query);
19986}
19987
19988/*
19989 * processExtensionTables --- deal with extension configuration tables
19990 *
19991 * There are two parts to this process:
19992 *
19993 * 1. Identify and create dump records for extension configuration tables.
19994 *
19995 * Extensions can mark tables as "configuration", which means that the user
19996 * is able and expected to modify those tables after the extension has been
19997 * loaded. For these tables, we dump out only the data- the structure is
19998 * expected to be handled at CREATE EXTENSION time, including any indexes or
19999 * foreign keys, which brings us to-
20000 *
20001 * 2. Record FK dependencies between configuration tables.
20002 *
20003 * Due to the FKs being created at CREATE EXTENSION time and therefore before
20004 * the data is loaded, we have to work out what the best order for reloading
20005 * the data is, to avoid FK violations when the tables are restored. This is
20006 * not perfect- we can't handle circular dependencies and if any exist they
20007 * will cause an invalid dump to be produced (though at least all of the data
20008 * is included for a user to manually restore). This is currently documented
20009 * but perhaps we can provide a better solution in the future.
20010 */
20011void
20014{
20016 PQExpBuffer query;
20017 PGresult *res;
20018 int ntups,
20019 i;
20021 i_confrelid;
20022
20023 /* Nothing to do if no extensions */
20025 return;
20026
20027 /*
20028 * Identify extension configuration tables and create TableDataInfo
20029 * objects for them, ensuring their data will be dumped even though the
20030 * tables themselves won't be.
20031 *
20032 * Note that we create TableDataInfo objects even in schema-only mode, ie,
20033 * user data in a configuration table is treated like schema data. This
20034 * seems appropriate since system data in a config table would get
20035 * reloaded by CREATE EXTENSION. If the extension is not listed in the
20036 * list of extensions to be included, none of its data is dumped.
20037 */
20039 {
20047
20048 /*
20049 * Check if this extension is listed as to include in the dump. If
20050 * not, any table data associated with it is discarded.
20051 */
20054 curext->dobj.catId.oid))
20055 continue;
20056
20057 /*
20058 * Check if this extension is listed as to exclude in the dump. If
20059 * yes, any table data associated with it is discarded.
20060 */
20063 curext->dobj.catId.oid))
20064 continue;
20065
20067 {
20069
20076
20078 {
20083
20086 continue;
20087
20088 /*
20089 * Tables of not-to-be-dumped extensions shouldn't be dumped
20090 * unless the table or its schema is explicitly included
20091 */
20093 {
20094 /* check table explicitly requested */
20097 configtbloid))
20099
20100 /* check table's schema explicitly requested */
20102 DUMP_COMPONENT_DATA)
20104 }
20105
20106 /* check table excluded by an exclusion switch */
20109 configtbloid))
20111
20112 /* check schema excluded by an exclusion switch */
20114 configtbl->dobj.namespace->dobj.catId.oid))
20116
20118 {
20121 {
20124 }
20125 }
20126 }
20127 }
20132 }
20133
20134 /*
20135 * Now that all the TableDataInfo objects have been created for all the
20136 * extensions, check their FK dependencies and register them to try and
20137 * dump the data out in an order that they can be restored in.
20138 *
20139 * Note that this is not a problem for user tables as their FKs are
20140 * recreated after the data has been loaded.
20141 */
20142
20143 query = createPQExpBuffer();
20144
20145 printfPQExpBuffer(query,
20146 "SELECT conrelid, confrelid "
20147 "FROM pg_constraint "
20148 "JOIN pg_depend ON (objid = confrelid) "
20149 "WHERE contype = 'f' "
20150 "AND refclassid = 'pg_extension'::regclass "
20151 "AND classid = 'pg_class'::regclass;");
20152
20154 ntups = PQntuples(res);
20155
20158
20159 /* Now get the dependencies and register them */
20161 {
20162 Oid conrelid,
20163 confrelid;
20165 *contable;
20166
20169 contable = findTableByOid(conrelid);
20171
20174 contable == NULL ||
20176 continue;
20177
20178 /*
20179 * Make referencing TABLE_DATA object depend on the referenced table's
20180 * TABLE_DATA object.
20181 */
20184 }
20185 PQclear(res);
20186 destroyPQExpBuffer(query);
20187}
20188
20189/*
20190 * getDependencies --- obtain available dependency data
20191 */
20192static void
20194{
20195 PQExpBuffer query;
20196 PGresult *res;
20197 int ntups,
20198 i;
20200 i_objid,
20201 i_refclassid,
20202 i_refobjid,
20203 i_deptype;
20204 DumpableObject *dobj,
20205 *refdobj;
20206
20208
20209 query = createPQExpBuffer();
20210
20211 /*
20212 * Messy query to collect the dependency data we need. Note that we
20213 * ignore the sub-object column, so that dependencies of or on a column
20214 * look the same as dependencies of or on a whole table.
20215 *
20216 * PIN dependencies aren't interesting, and EXTENSION dependencies were
20217 * already processed by getExtensionMembership.
20218 */
20220 "classid, objid, refclassid, refobjid, deptype "
20221 "FROM pg_depend "
20222 "WHERE deptype != 'p' AND deptype != 'e'\n");
20223
20224 /*
20225 * Since we don't treat pg_amop entries as separate DumpableObjects, we
20226 * have to translate their dependencies into dependencies of their parent
20227 * opfamily. Ignore internal dependencies though, as those will point to
20228 * their parent opclass, which we needn't consider here (and if we did,
20229 * it'd just result in circular dependencies). Also, "loose" opfamily
20230 * entries will have dependencies on their parent opfamily, which we
20231 * should drop since they'd likewise become useless self-dependencies.
20232 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
20233 */
20235 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
20236 "FROM pg_depend d, pg_amop o "
20237 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20238 "classid = 'pg_amop'::regclass AND objid = o.oid "
20239 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n");
20240
20241 /* Likewise for pg_amproc entries */
20243 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
20244 "FROM pg_depend d, pg_amproc p "
20245 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20246 "classid = 'pg_amproc'::regclass AND objid = p.oid "
20247 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n");
20248
20249 /* Sort the output for efficiency below */
20251
20253
20254 ntups = PQntuples(res);
20255
20261
20262 /*
20263 * Since we ordered the SELECT by referencing ID, we can expect that
20264 * multiple entries for the same object will appear together; this saves
20265 * on searches.
20266 */
20267 dobj = NULL;
20268
20270 {
20271 CatalogId objId;
20273 char deptype;
20274
20280
20284 dobj = findObjectByCatalogId(objId);
20285
20286 /*
20287 * Failure to find objects mentioned in pg_depend is not unexpected,
20288 * since for example we don't collect info about TOAST tables.
20289 */
20291 {
20292#ifdef NOT_USED
20295#endif
20296 continue;
20297 }
20298
20300
20302 {
20303#ifdef NOT_USED
20306#endif
20307 continue;
20308 }
20309
20310 /*
20311 * For 'x' dependencies, mark the object for later; we still add the
20312 * normal dependency, for possible ordering purposes. Currently
20313 * pg_dump_sort.c knows to put extensions ahead of all object types
20314 * that could possibly depend on them, but this is safer.
20315 */
20316 if (deptype == 'x')
20318
20319 /*
20320 * Ordinarily, table rowtypes have implicit dependencies on their
20321 * tables. However, for a composite type the implicit dependency goes
20322 * the other way in pg_depend; which is the right thing for DROP but
20323 * it doesn't produce the dependency ordering we need. So in that one
20324 * case, we reverse the direction of the dependency.
20325 */
20326 if (deptype == 'i' &&
20330 else
20331 /* normal case */
20333 }
20334
20335 PQclear(res);
20336
20337 destroyPQExpBuffer(query);
20338}
20339
20340
20341/*
20342 * createBoundaryObjects - create dummy DumpableObjects to represent
20343 * dump section boundaries.
20344 */
20347{
20349
20351
20356
20361
20363}
20364
20365/*
20366 * addBoundaryDependencies - add dependencies as needed to enforce the dump
20367 * section boundaries.
20368 */
20369static void
20372{
20376
20378 {
20380
20381 /*
20382 * The classification of object types here must match the SECTION_xxx
20383 * values assigned during subsequent ArchiveEntry calls!
20384 */
20386 {
20412 /* Pre-data objects: must come before the pre-data boundary */
20414 break;
20419 /* Data objects: must come between the boundaries */
20422 break;
20436 /* Post-data objects: must come after the post-data boundary */
20438 break;
20440 /* Rules are post-data, but only if dumped separately */
20443 break;
20446 /* Constraints are post-data, but only if dumped separately */
20449 break;
20451 /* nothing to do */
20452 break;
20454 /* must come after the pre-data boundary */
20456 break;
20458 /* stats section varies by parent object type, DATA or POST */
20460 {
20463 }
20464 else
20466 break;
20467 }
20468 }
20469}
20470
20471
20472/*
20473 * BuildArchiveDependencies - create dependency data for archive TOC entries
20474 *
20475 * The raw dependency data obtained by getDependencies() is not terribly
20476 * useful in an archive dump, because in many cases there are dependency
20477 * chains linking through objects that don't appear explicitly in the dump.
20478 * For example, a view will depend on its _RETURN rule while the _RETURN rule
20479 * will depend on other objects --- but the rule will not appear as a separate
20480 * object in the dump. We need to adjust the view's dependencies to include
20481 * whatever the rule depends on that is included in the dump.
20482 *
20483 * Just to make things more complicated, there are also "special" dependencies
20484 * such as the dependency of a TABLE DATA item on its TABLE, which we must
20485 * not rearrange because pg_restore knows that TABLE DATA only depends on
20486 * its table. In these cases we must leave the dependencies strictly as-is
20487 * even if they refer to not-to-be-dumped objects.
20488 *
20489 * To handle this, the convention is that "special" dependencies are created
20490 * during ArchiveEntry calls, and an archive TOC item that has any such
20491 * entries will not be touched here. Otherwise, we recursively search the
20492 * DumpableObject data structures to build the correct dependencies for each
20493 * archive TOC item.
20494 */
20495static void
20497{
20499 TocEntry *te;
20500
20501 /* Scan all TOC entries in the archive */
20503 {
20504 DumpableObject *dobj;
20505 DumpId *dependencies;
20506 int nDeps;
20507 int allocDeps;
20508
20509 /* No need to process entries that will not be dumped */
20511 continue;
20512 /* Ignore entries that already have "special" dependencies */
20514 continue;
20515 /* Otherwise, look up the item's original DumpableObject, if any */
20518 continue;
20519 /* No work if it has no dependencies */
20521 continue;
20522 /* Set up work array */
20523 allocDeps = 64;
20525 nDeps = 0;
20526 /* Recursively find all dumpable dependencies */
20527 findDumpableDependencies(AH, dobj,
20528 &dependencies, &nDeps, &allocDeps);
20529 /* And save 'em ... */
20530 if (nDeps > 0)
20531 {
20534 te->dependencies = dependencies;
20535 te->nDeps = nDeps;
20536 }
20537 else
20538 free(dependencies);
20539 }
20540}
20541
20542/* Recursive search subroutine for BuildArchiveDependencies */
20543static void
20546{
20548
20549 /*
20550 * Ignore section boundary objects: if we search through them, we'll
20551 * report lots of bogus dependencies.
20552 */
20555 return;
20556
20558 {
20560
20562 {
20563 /* Object will be dumped, so just reference it as a dependency */
20564 if (*nDeps >= *allocDeps)
20565 {
20566 *allocDeps *= 2;
20569 }
20570 (*dependencies)[*nDeps] = depid;
20571 (*nDeps)++;
20572 }
20573 else
20574 {
20575 /*
20576 * Object will not be dumped, so recursively consider its deps. We
20577 * rely on the assumption that sortDumpableObjects already broke
20578 * any dependency loops, else we might recurse infinitely.
20579 */
20581
20584 dependencies, nDeps, allocDeps);
20585 }
20586 }
20587}
20588
20589
20590/*
20591 * getFormattedTypeName - retrieve a nicely-formatted type name for the
20592 * given type OID.
20593 *
20594 * This does not guarantee to schema-qualify the output, so it should not
20595 * be used to create the target object name for CREATE or ALTER commands.
20596 *
20597 * Note that the result is cached and must not be freed by the caller.
20598 */
20599static const char *
20601{
20603 char *result;
20604 PQExpBuffer query;
20605 PGresult *res;
20606
20607 if (oid == 0)
20608 {
20610 return "*";
20612 return "NONE";
20613 }
20614
20615 /* see if we have the result cached in the type's TypeInfo record */
20619
20620 query = createPQExpBuffer();
20622 oid);
20623
20625
20626 /* result of format_type is already quoted */
20628
20629 PQclear(res);
20630 destroyPQExpBuffer(query);
20631
20632 /*
20633 * Cache the result for re-use in later requests, if possible. If we
20634 * don't have a TypeInfo for the type, the string will be leaked once the
20635 * caller is done with it ... but that case really should not happen, so
20636 * leaking if it does seems acceptable.
20637 */
20639 typeInfo->ftypname = result;
20640
20641 return result;
20642}
20643
20644/*
20645 * Return a column list clause for the given relation.
20646 *
20647 * Special case: if there are no undropped columns in the relation, return
20648 * "", not an invalid "()" column list.
20649 */
20650static const char *
20652{
20659
20663 {
20665 continue;
20667 continue;
20672 }
20673
20675 return ""; /* no undropped columns */
20676
20679}
20680
20681/*
20682 * Check if a reloptions array is nonempty.
20683 */
20684static bool
20686{
20687 /* Don't want to print it if it's just "{}" */
20689}
20690
20691/*
20692 * Format a reloptions array and append it to the given buffer.
20693 *
20694 * "prefix" is prepended to the option names; typically it's "" or "toast.".
20695 */
20696static void
20699{
20700 bool res;
20701
20703 fout->std_strings);
20704 if (!res)
20706}
20707
20708/*
20709 * read_dump_filters - retrieve object identifier patterns from file
20710 *
20711 * Parse the specified filter file for include and exclude patterns, and add
20712 * them to the relevant lists. If the filename is "-" then filters will be
20713 * read from STDIN rather than a file.
20714 */
20715static void
20717{
20719 char *objname;
20721 FilterObjectType objtype;
20722
20724
20726 {
20728 {
20729 switch (objtype)
20730 {
20732 break;
20740 "include",
20741 filter_object_type_name(objtype));
20742 exit_nicely(1);
20743 break; /* unreachable */
20744
20747 break;
20750 break;
20754 break;
20758 break;
20761 objname);
20763 break;
20764 }
20765 }
20767 {
20768 switch (objtype)
20769 {
20771 break;
20778 "exclude",
20779 filter_object_type_name(objtype));
20780 exit_nicely(1);
20781 break;
20782
20785 break;
20788 objname);
20789 break;
20792 objname);
20793 break;
20796 break;
20799 break;
20802 objname);
20803 break;
20804 }
20805 }
20806 else
20807 {
20810 }
20811
20812 if (objname)
20813 free(objname);
20814 }
20815
20817}
void recordAdditionalCatalogID(CatalogId catId, DumpableObject *dobj)
Definition common.c:719
void recordExtensionMembership(CatalogId catId, ExtensionInfo *ext)
Definition common.c:1063
void addObjectDependency(DumpableObject *dobj, DumpId refId)
Definition common.c:818
DumpableObject * findObjectByCatalogId(CatalogId catalogId)
Definition common.c:778
void getDumpableObjects(DumpableObject ***objs, int *numObjs)
Definition common.c:797
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition exec.c:430
char * supports_compression(const pg_compress_specification compression_spec)
Definition compress_io.c:87
char * validate_compress_specification(pg_compress_specification *spec)
Definition compression.c:344
bool parse_compress_algorithm(char *name, pg_compress_algorithm *algorithm)
Definition compression.c:49
void parse_compress_specification(pg_compress_algorithm algorithm, char *specification, pg_compress_specification *result)
Definition compression.c:107
void parse_compress_options(const char *option, char **algorithm, char **detail)
bool buildACLCommands(const char *name, const char *subname, const char *nspname, const char *type, const char *acls, const char *baseacls, const char *owner, const char *prefix, int remoteVersion, PQExpBuffer sql)
Definition dumputils.c:104
void buildShSecLabelQuery(const char *catalog_name, Oid objectId, PQExpBuffer sql)
Definition dumputils.c:678
void makeAlterConfigCommand(PGconn *conn, const char *configitem, const char *type, const char *name, const char *type2, const char *name2, PQExpBuffer buf)
Definition dumputils.c:865
bool buildDefaultACLCommands(const char *type, const char *nspname, const char *acls, const char *acldefault, const char *owner, int remoteVersion, PQExpBuffer sql)
Definition dumputils.c:366
bool variable_is_guc_list_quote(const char *name)
Definition dumputils.c:730
void quoteAclUserName(PQExpBuffer output, const char *input)
Definition dumputils.c:585
void emitShSecLabels(PGconn *conn, PGresult *res, PQExpBuffer buffer, const char *objtype, const char *objname)
Definition dumputils.c:696
const char * PQparameterStatus(const PGconn *conn, const char *paramName)
Definition fe-connect.c:7659
int PQsetClientEncoding(PGconn *conn, const char *encoding)
Definition fe-connect.c:7802
void filter_init(FilterStateData *fstate, const char *filename, exit_function f_exit)
Definition filter.c:36
const char * filter_object_type_name(FilterObjectType fot)
Definition filter.c:82
bool filter_read_item(FilterStateData *fstate, char **objname, FilterCommandType *comtype, FilterObjectType *objtype)
Definition filter.c:392
void pg_log_filter_error(FilterStateData *fstate, const char *fmt,...)
Definition filter.c:154
@ FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN
Definition filter.h:51
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition getopt_long.c:60
static struct @172 value
bool option_parse_int(const char *optarg, const char *optname, int min_range, int max_range, int *result)
Definition option_utils.c:50
bool parse_sync_method(const char *optarg, DataDirSyncMethod *sync_method)
Definition option_utils.c:90
void ProcessArchiveRestoreOptions(Archive *AHX)
Definition pg_backup_archiver.c:289
enum _archiveFormat ArchiveFormat
void ConnectDatabaseAhx(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition pg_backup_db.c:109
Archive * CreateArchive(const char *FileSpec, const ArchiveFormat fmt, const pg_compress_specification compression_spec, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupDumpWorker, DataDirSyncMethod sync_method)
Definition pg_backup_archiver.c:231
int archprintf(Archive *AH, const char *fmt,...) pg_attribute_printf(2
void SetArchiveOptions(Archive *AH, DumpOptions *dopt, RestoreOptions *ropt)
Definition pg_backup_archiver.c:276
void WriteData(Archive *AHX, const void *data, size_t dLen)
Definition pg_backup_archiver.c:1220
TocEntry * ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
Definition pg_backup_archiver.c:1241
int(* DataDumperPtr)(Archive *AH, const void *userArg)
Definition pg_backup_archiver.h:335
void ExecuteSqlStatement(Archive *AHX, const char *query)
Definition pg_backup_db.c:217
PGresult * ExecuteSqlQuery(Archive *AHX, const char *query, ExecStatusType status)
Definition pg_backup_db.c:229
PGresult * ExecuteSqlQueryForSingleRow(Archive *fout, const char *query)
Definition pg_backup_db.c:244
void set_dump_section(const char *arg, int *dumpSections)
Definition pg_backup_utils.c:42
static void expand_schema_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
Definition pg_dump.c:1677
void getConstraints(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8308
static DumpId dumpACL(Archive *fout, DumpId objDumpId, DumpId altDumpId, const char *type, const char *name, const char *subname, const char *nspname, const char *tag, const char *owner, const DumpableAcl *dacl)
Definition pg_dump.c:16426
static void dumpAttrDef(Archive *fout, const AttrDefInfo *adinfo)
Definition pg_dump.c:18193
ExtensionInfo * getExtensions(Archive *fout, int *numExtensions)
Definition pg_dump.c:6137
static void selectDumpableProcLang(ProcLangInfo *plang, Archive *fout)
Definition pg_dump.c:2229
static void collectBinaryUpgradeClassOids(Archive *fout)
Definition pg_dump.c:5837
static PQExpBuffer createDummyViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17070
static void dumpUserMappings(Archive *fout, const char *servername, const char *namespace, const char *owner, CatalogId catalogId, DumpId dumpId)
Definition pg_dump.c:16240
static void dumpPublicationNamespace(Archive *fout, const PublicationSchemaInfo *pubsinfo)
Definition pg_dump.c:4977
static void addBoundaryDependencies(DumpableObject **dobjs, int numObjs, DumpableObject *boundaryObjs)
Definition pg_dump.c:20371
static void selectDumpableTable(TableInfo *tbinfo, Archive *fout)
Definition pg_dump.c:2098
static char * convertTSFunction(Archive *fout, Oid funcOid)
Definition pg_dump.c:14413
static void append_depends_on_extension(Archive *fout, PQExpBuffer create, const DumpableObject *dobj, const char *catalog, const char *keyword, const char *objname)
Definition pg_dump.c:5650
static Oid get_next_possible_free_pg_type_oid(Archive *fout, PQExpBuffer upgrade_query)
Definition pg_dump.c:5695
static void dumpNamespace(Archive *fout, const NamespaceInfo *nspinfo)
Definition pg_dump.c:11875
static bool forcePartitionRootLoad(const TableInfo *tbinfo)
Definition pg_dump.c:2856
static void dumpBaseType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12468
static char * dumpRelationStats_dumper(Archive *fout, const void *userArg, const TocEntry *te)
Definition pg_dump.c:11119
static void dumpTSDictionary(Archive *fout, const TSDictInfo *dictinfo)
Definition pg_dump.c:15812
static void dumpRelationStats(Archive *fout, const RelStatsInfo *rsinfo)
Definition pg_dump.c:11392
static void dumpTableComment(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:11418
static SimpleStringList extension_include_patterns
Definition pg_dump.c:185
static void selectDumpableNamespace(NamespaceInfo *nsinfo, Archive *fout)
Definition pg_dump.c:2012
static void dumpTrigger(Archive *fout, const TriggerInfo *tginfo)
Definition pg_dump.c:19537
static void binary_upgrade_set_type_oids_by_rel(Archive *fout, PQExpBuffer upgrade_buffer, const TableInfo *tbinfo)
Definition pg_dump.c:5806
static PQExpBuffer createViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17021
static void dumpStatisticsExt(Archive *fout, const StatsExtInfo *statsextinfo)
Definition pg_dump.c:18477
void getPolicies(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4261
static void dumpRangeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12246
void getExtensionMembership(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:19920
static void dumpComment(Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
Definition pg_dump.c:10997
static char * getFormattedOperatorName(const char *oproid)
Definition pg_dump.c:14383
static char * format_function_signature(Archive *fout, const FuncInfo *finfo, bool honor_quotes)
Definition pg_dump.c:13438
static void dumpConstraint(Archive *fout, const ConstraintInfo *coninfo)
Definition pg_dump.c:18757
static void dumpTableAttach(Archive *fout, const TableAttachInfo *attachinfo)
Definition pg_dump.c:18125
static void dumpAccessMethod(Archive *fout, const AccessMethodInfo *aminfo)
Definition pg_dump.c:14435
static void selectDumpableStatisticsObject(StatsExtInfo *sobj, Archive *fout)
Definition pg_dump.c:2354
static void selectDumpablePublicationObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2336
static void dumpSequenceData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:19448
static void selectDumpableDefaultACL(DefaultACLInfo *dinfo, DumpOptions *dopt)
Definition pg_dump.c:2182
static void BuildArchiveDependencies(Archive *fout)
Definition pg_dump.c:20497
static RelStatsInfo * getRelationStatistics(Archive *fout, DumpableObject *rel, int32 relpages, char *reltuples, int32 relallvisible, int32 relallfrozen, char relkind, char **indAttNames, int nindAttNames)
Definition pg_dump.c:7122
void getOwnedSeqs(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7676
static void makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo)
Definition pg_dump.c:3053
static const char * getAttrName(int attrnum, const TableInfo *tblInfo)
Definition pg_dump.c:18254
static void dumpForeignServer(Archive *fout, const ForeignServerInfo *srvinfo)
Definition pg_dump.c:16140
static void appendReloptionsArrayAH(PQExpBuffer buffer, const char *reloptions, const char *prefix, Archive *fout)
Definition pg_dump.c:20698
static void dumpTableData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2884
static void prohibit_crossdb_refs(PGconn *conn, const char *dbname, const char *pattern)
Definition pg_dump.c:1937
static int dumpTableData_copy(Archive *fout, const void *dcontext)
Definition pg_dump.c:2394
static const char * getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts)
Definition pg_dump.c:20601
static void buildMatViewRefreshDependencies(Archive *fout)
Definition pg_dump.c:3140
static void binary_upgrade_set_type_oids_by_type_oid(Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_type_oid, bool force_array_type, bool include_multirange_type)
Definition pg_dump.c:5726
void getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4850
static void dumpShellType(Archive *fout, const ShellTypeInfo *stinfo)
Definition pg_dump.c:13237
static void refreshMatViewData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2999
static int findComments(Oid classoid, Oid objoid, CommentItem **items)
Definition pg_dump.c:11516
static SimpleStringList foreign_servers_include_patterns
Definition pg_dump.c:182
static void selectDumpableCast(CastInfo *cast, Archive *fout)
Definition pg_dump.c:2204
static void dumpPublication(Archive *fout, const PublicationInfo *pubinfo)
Definition pg_dump.c:4667
void getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7857
static void addConstrChildIdxDeps(DumpableObject *dobj, const IndxInfo *refidx)
Definition pg_dump.c:8467
static int findSecLabels(Oid classoid, Oid objoid, SecLabelItem **items)
Definition pg_dump.c:16716
static SimpleStringList table_include_patterns_and_children
Definition pg_dump.c:173
static char * convertRegProcReference(const char *proc)
Definition pg_dump.c:14342
static void getTableData(DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind)
Definition pg_dump.c:3034
void getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables)
Definition pg_dump.c:9251
static void getDomainConstraints(Archive *fout, TypeInfo *tyinfo)
Definition pg_dump.c:8490
static void dumpOpfamily(Archive *fout, const OpfamilyInfo *opfinfo)
Definition pg_dump.c:14784
static void dumpDefaultACL(Archive *fout, const DefaultACLInfo *daclinfo)
Definition pg_dump.c:16334
static void selectDumpableObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2372
static void dumpTSTemplate(Archive *fout, const TSTemplateInfo *tmplinfo)
Definition pg_dump.c:15892
static void dumpIndexAttach(Archive *fout, const IndexAttachInfo *attachinfo)
Definition pg_dump.c:18434
static void dumpSubscriptionTable(Archive *fout, const SubRelInfo *subrinfo)
Definition pg_dump.c:5427
static char * format_function_arguments(const FuncInfo *finfo, const char *funcargs, bool is_agg)
Definition pg_dump.c:13415
static void dumpTransform(Archive *fout, const TransformInfo *transform)
Definition pg_dump.c:13994
static void dumpPublicationTable(Archive *fout, const PublicationRelInfo *pubrinfo)
Definition pg_dump.c:5020
static void binary_upgrade_extension_member(PQExpBuffer upgrade_buffer, const DumpableObject *dobj, const char *objtype, const char *objname, const char *objnamespace)
Definition pg_dump.c:5961
static void dumpDumpableObject(Archive *fout, DumpableObject *dobj)
Definition pg_dump.c:11678
static void dumpDatabaseConfig(Archive *AH, PQExpBuffer outbuf, const char *dbname, Oid dboid)
Definition pg_dump.c:3805
static void setup_connection(Archive *AH, const char *dumpencoding, const char *dumpsnapshot, char *use_role)
Definition pg_dump.c:1429
static void dumpTableConstraintComment(Archive *fout, const ConstraintInfo *coninfo)
Definition pg_dump.c:19078
static void dumpUndefinedType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12404
static void selectDumpableAccessMethod(AccessMethodInfo *method, Archive *fout)
Definition pg_dump.c:2262
static const char * fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer)
Definition pg_dump.c:20652
static void expand_table_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names, bool with_child_tables)
Definition pg_dump.c:1841
static void findDumpableDependencies(ArchiveHandle *AH, const DumpableObject *dobj, DumpId **dependencies, int *nDeps, int *allocDeps)
Definition pg_dump.c:20545
static void determineNotNullFlags(Archive *fout, PGresult *res, int r, TableInfo *tbinfo, int j, int i_notnull_name, int i_notnull_comment, int i_notnull_invalidoid, int i_notnull_noinherit, int i_notnull_islocal, PQExpBuffer *invalidnotnulloids)
Definition pg_dump.c:10028
static void dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17110
static void dumpTSParser(Archive *fout, const TSParserInfo *prsinfo)
Definition pg_dump.c:15748
static void expand_foreign_server_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
Definition pg_dump.c:1789
static void dumpCompositeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12942
static void dumpEnumType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12106
static void dumpExtension(Archive *fout, const ExtensionInfo *extinfo)
Definition pg_dump.c:11952
static SimpleStringList extension_exclude_patterns
Definition pg_dump.c:188
static BinaryUpgradeClassOidItem * binaryUpgradeClassOids
Definition pg_dump.c:210
static void dumpStatisticsExtStats(Archive *fout, const StatsExtInfo *statsextinfo)
Definition pg_dump.c:18554
static char * get_synchronized_snapshot(Archive *fout)
Definition pg_dump.c:1625
static void dumpSubscription(Archive *fout, const SubscriptionInfo *subinfo)
Definition pg_dump.c:5496
static void appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname, const char *argtype, const char *argval)
Definition pg_dump.c:11013
void processExtensionTables(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:20013
static void dumpEventTrigger(Archive *fout, const EventTriggerInfo *evtinfo)
Definition pg_dump.c:19663
static int BinaryUpgradeClassOidItemCmp(const void *p1, const void *p2)
Definition pg_dump.c:5821
static void dumpCommentExtended(Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId, const char *initdb_comment)
Definition pg_dump.c:10897
static SimpleStringList tabledata_exclude_patterns
Definition pg_dump.c:178
static void dumpConversion(Archive *fout, const ConvInfo *convinfo)
Definition pg_dump.c:15260
static void dumpForeignDataWrapper(Archive *fout, const FdwInfo *fdwinfo)
Definition pg_dump.c:16070
static void dumpProcLang(Archive *fout, const ProcLangInfo *plang)
Definition pg_dump.c:13283
static void dumpSecLabel(Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
Definition pg_dump.c:16554
static void selectDumpableExtension(ExtensionInfo *extinfo, DumpOptions *dopt)
Definition pg_dump.c:2297
void getTriggers(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8699
static ArchiveFormat parseArchiveFormat(const char *format, ArchiveMode *mode)
Definition pg_dump.c:1639
static void read_dump_filters(const char *filename, DumpOptions *dopt)
Definition pg_dump.c:20717
static void dumpTSConfig(Archive *fout, const TSConfigInfo *cfginfo)
Definition pg_dump.c:15950
static SimpleStringList tabledata_exclude_patterns_and_children
Definition pg_dump.c:179
static char * get_language_name(Archive *fout, Oid langid)
Definition pg_dump.c:9146
static bool checkExtensionMembership(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:1962
static int dumpTableData_insert(Archive *fout, const void *dcontext)
Definition pg_dump.c:2562
static SimpleStringList table_exclude_patterns_and_children
Definition pg_dump.c:176
static void binary_upgrade_set_pg_class_oids(Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_class_oid)
Definition pg_dump.c:5871
static void set_restrict_relation_kind(Archive *AH, const char *value)
Definition pg_dump.c:5100
static char * format_aggregate_signature(const AggInfo *agginfo, Archive *fout, bool honor_quotes)
Definition pg_dump.c:15356
static void dumpSequence(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:19194
bool shouldPrintColumn(const DumpOptions *dopt, const TableInfo *tbinfo, int colno)
Definition pg_dump.c:10155
static TableInfo * getRootTableInfo(const TableInfo *tbinfo)
Definition pg_dump.c:2831
static SimpleOidList foreign_servers_include_oids
Definition pg_dump.c:183
static void dumpCollation(Archive *fout, const CollInfo *collinfo)
Definition pg_dump.c:15003
static void dumpTableSecLabel(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:16634
static void dumpCompositeTypeColComments(Archive *fout, const TypeInfo *tyinfo, PGresult *res)
Definition pg_dump.c:13148
static void expand_extension_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
Definition pg_dump.c:1736
static void selectDumpableType(TypeInfo *tyinfo, Archive *fout)
Definition pg_dump.c:2137
static void dumpOpclass(Archive *fout, const OpclassInfo *opcinfo)
Definition pg_dump.c:14503
void sortDumpableObjects(DumpableObject **objs, int numObjs, DumpId preBoundaryId, DumpId postBoundaryId)
Definition pg_dump_sort.c:559
void sortDumpableObjectsByTypeName(DumpableObject **objs, int numObjs)
Definition pg_dump_sort.c:192
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition pqexpbuffer.c:235
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition pqexpbuffer.c:265
void appendBinaryPQExpBuffer(PQExpBuffer str, const char *data, size_t datalen)
Definition pqexpbuffer.c:397
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition pqexpbuffer.c:378
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition pqexpbuffer.c:367
void simple_string_list_append(SimpleStringList *list, const char *val)
Definition simple_list.c:63
bool simple_oid_list_member(SimpleOidList *list, Oid val)
Definition simple_list.c:45
void simple_oid_list_append(SimpleOidList *list, Oid val)
Definition simple_list.c:26
#define PG_DEPENDENCIES_KEY_ATTRIBUTES
Definition statistics_format.h:43
#define PG_DEPENDENCIES_KEY_DEPENDENCY
Definition statistics_format.h:44
void appendStringLiteralConn(PQExpBuffer buf, const char *str, PGconn *conn)
Definition string_utils.c:446
bool processSQLNamePattern(PGconn *conn, PQExpBuffer buf, const char *pattern, bool have_where, bool force_escape, const char *schemavar, const char *namevar, const char *altnamevar, const char *visibilityrule, PQExpBuffer dbnamebuf, int *dotcnt)
Definition string_utils.c:1053
bool parsePGArray(const char *atext, char ***itemarray, int *nitems)
Definition string_utils.c:819
bool appendReloptionsArray(PQExpBuffer buffer, const char *reloptions, const char *prefix, int encoding, bool std_strings)
Definition string_utils.c:966
void appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
Definition string_utils.c:484
Definition pathnodes.h:3631
Definition pg_backup.h:228
Definition pg_dump.c:101
RelFileNumber toast_index_relfilenumber
Definition pg_dump.c:108
RelFileNumber toast_relfilenumber
Definition pg_dump.c:106
Definition pg_backup.h:279
Definition pg_dump.c:84
Definition filter.h:26
Definition pqexpbuffer.h:45
Definition pg_publication.h:145
Definition pg_dump.c:78
Definition pg_dump.c:92
Definition pg_dump.c:130
Definition simple_list.h:27
Definition simple_list.h:47
Definition simple_list.h:53
Definition simple_list.h:33
Definition simple_list.h:41
Definition pg_dump.h:668
Definition pg_dump.h:699
Definition pg_dump.h:741
Definition pg_dump.h:709
Definition pg_dump.h:269
Definition pg_backup_archiver.h:205
Definition pg_dump.h:403
Definition pg_dump.h:543
Definition pg_dump.h:594
Definition pg_dump.h:290
Definition pg_dump.h:516
Definition pg_dump.h:297
Definition pg_dump.h:622
Definition pg_dump.h:579
Definition pg_backup.h:172
Definition pg_dump.h:169
Definition pg_dump.h:179
Definition pg_dump.h:148
Definition pg_dump.h:495
Definition pg_dump.h:194
Definition pg_dump.h:601
Definition pg_dump.h:611
Definition pg_dump.h:240
Definition pg_dump.h:442
Definition pg_dump.h:419
Definition pg_dump.h:563
Definition pg_dump.h:638
Definition pg_dump.h:185
Definition pg_dump.h:276
Definition pg_dump.h:283
Definition pg_dump.h:259
Definition pg_dump.h:653
Definition pg_dump.h:532
Definition pg_dump.h:569
Definition pg_dump.h:449
Definition pg_backup.h:98
pg_compress_specification compression_spec
Definition pg_backup.h:150
Definition pg_dump.h:475
Definition pg_dump.h:233
Definition pg_dump.h:467
Definition pg_dump.h:396
Definition pg_dump.h:412
Definition pg_dump.h:303
Definition pg_dump.h:587
Definition pg_backup_archiver.h:338
Definition pg_dump.h:553
Definition pg_dump.h:486
Definition pg_dump.h:204
Definition getopt_long.h:18
Definition compression.h:33
Definition libpq-int.h:372
Definition libpq-int.h:165
Definition oauth-curl.c:115
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition varlena.c:2978
◆ MAX_ATTR_STATS_RELS
◆ MAX_BLOBS_PER_ARCHIVE_ENTRY
Typedef Documentation
◆ OidOptions
◆ SeqType
Enumeration Type Documentation
◆ OidOptions
◆ SeqType
Function Documentation
◆ addBoundaryDependencies()
|
static |
Definition at line 20371 of file pg_dump.c.
20373{
20377
20379 {
20381
20382 /*
20383 * The classification of object types here must match the SECTION_xxx
20384 * values assigned during subsequent ArchiveEntry calls!
20385 */
20387 {
20413 /* Pre-data objects: must come before the pre-data boundary */
20415 break;
20420 /* Data objects: must come between the boundaries */
20423 break;
20437 /* Post-data objects: must come after the post-data boundary */
20439 break;
20441 /* Rules are post-data, but only if dumped separately */
20444 break;
20447 /* Constraints are post-data, but only if dumped separately */
20450 break;
20452 /* nothing to do */
20453 break;
20455 /* must come after the pre-data boundary */
20457 break;
20459 /* stats section varies by parent object type, DATA or POST */
20461 {
20464 }
20465 else
20467 break;
20468 }
20469 }
20470}
References addObjectDependency(), DO_ACCESS_METHOD, DO_AGG, DO_ATTRDEF, DO_CAST, DO_COLLATION, DO_CONSTRAINT, DO_CONVERSION, DO_DEFAULT_ACL, DO_DUMMY_TYPE, DO_EVENT_TRIGGER, DO_EXTENSION, DO_FDW, DO_FK_CONSTRAINT, DO_FOREIGN_SERVER, DO_FUNC, DO_INDEX, DO_INDEX_ATTACH, DO_LARGE_OBJECT, DO_LARGE_OBJECT_DATA, DO_NAMESPACE, DO_OPCLASS, DO_OPERATOR, DO_OPFAMILY, DO_POLICY, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, DO_PROCLANG, DO_PUBLICATION, DO_PUBLICATION_REL, DO_PUBLICATION_TABLE_IN_SCHEMA, DO_REFRESH_MATVIEW, DO_REL_STATS, DO_RULE, DO_SEQUENCE_SET, DO_SHELL_TYPE, DO_STATSEXT, DO_SUBSCRIPTION, DO_SUBSCRIPTION_REL, DO_TABLE, DO_TABLE_ATTACH, DO_TABLE_DATA, DO_TRANSFORM, DO_TRIGGER, DO_TSCONFIG, DO_TSDICT, DO_TSPARSER, DO_TSTEMPLATE, DO_TYPE, _dumpableObject::dumpId, fb(), i, _dumpableObject::objType, and SECTION_DATA.
Referenced by main().
◆ addConstrChildIdxDeps()
|
static |
Definition at line 8467 of file pg_dump.c.
References addConstrChildIdxDeps(), addObjectDependency(), Assert, DO_FK_CONSTRAINT, _dumpableObject::dumpId, fb(), SimplePtrListCell::next, _dumpableObject::objType, and SimplePtrListCell::ptr.
Referenced by addConstrChildIdxDeps(), and getConstraints().
◆ append_depends_on_extension()
|
static |
Definition at line 5650 of file pg_dump.c.
5656{
5658 {
5660 PGresult *res;
5661 PQExpBuffer query;
5662 int ntups;
5665
5666 /* dodge fmtId() non-reentrancy */
5668
5669 query = createPQExpBuffer();
5670 appendPQExpBuffer(query,
5671 "SELECT e.extname "
5672 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5673 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5674 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5675 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5676 catalog,
5679 ntups = PQntuples(res);
5682 {
5684 keyword, nm,
5686 }
5687
5688 PQclear(res);
5689 destroyPQExpBuffer(query);
5691 }
5692}
References appendPQExpBuffer(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::depends_on_ext, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), fmtId(), i, CatalogId::oid, pg_free(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, and PQntuples.
Referenced by dumpConstraint(), dumpFunc(), dumpIndex(), dumpTableSchema(), and dumpTrigger().
◆ appendNamedArgument()
|
static |
Definition at line 11013 of file pg_dump.c.
11015{
11017
11020
11023}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, and fb().
Referenced by dumpRelationStats_dumper(), and dumpStatisticsExtStats().
◆ appendReloptionsArrayAH()
|
static |
Definition at line 20698 of file pg_dump.c.
References appendReloptionsArray(), fb(), and pg_log_warning.
Referenced by dumpConstraint(), dumpRule(), and dumpTableSchema().
◆ binary_upgrade_extension_member()
|
static |
Definition at line 5961 of file pg_dump.c.
5966{
5969
5971 return;
5972
5973 /*
5974 * Find the parent extension. We could avoid this search if we wanted to
5975 * add a link field to DumpableObject, but the space costs of that would
5976 * be considerable. We assume that member objects could only have a
5977 * direct dependency on their own extension, not any others.
5978 */
5980 {
5983 break;
5985 }
5988 objtype, objname);
5989
5991 "\n-- For binary upgrade, handle extension membership the hard way\n");
5994 objtype);
5998}
References appendPQExpBuffer(), appendPQExpBufferStr(), _dumpableObject::dependencies, DO_EXTENSION, _dumpableObject::ext_member, fb(), findObjectByDumpId(), fmtId(), i, _dumpableObject::nDeps, and pg_fatal.
Referenced by dumpAccessMethod(), dumpAgg(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpProcLang(), dumpRangeType(), dumpSequence(), dumpTableSchema(), dumpTransform(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), and dumpUndefinedType().
◆ binary_upgrade_set_pg_class_oids()
|
static |
Definition at line 5871 of file pg_dump.c.
5873{
5875 BinaryUpgradeClassOidItem *entry;
5876
5878
5879 /*
5880 * Preserve the OID and relfilenumber of the table, table's index, table's
5881 * toast table and toast table's index if any.
5882 *
5883 * One complexity is that the current table definition might not require
5884 * the creation of a TOAST table, but the old database might have a TOAST
5885 * table that was created earlier, before some wide columns were dropped.
5886 * By setting the TOAST oid we force creation of the TOAST heap and index
5887 * by the new backend, so we can copy the files during binary upgrade
5888 * without worrying about this case.
5889 */
5893 BinaryUpgradeClassOidItemCmp);
5894
5896 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5897
5900 {
5902 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5903 pg_class_oid);
5904
5905 /*
5906 * Not every relation has storage. Also, in a pre-v12 database,
5907 * partitioned tables have a relfilenumber, which should not be
5908 * preserved when upgrading.
5909 */
5913 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5914 entry->relfilenumber);
5915
5916 /*
5917 * In a pre-v12 database, partitioned tables might be marked as having
5918 * toast tables, but we should ignore them if so.
5919 */
5922 {
5924 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
5925 entry->toast_oid);
5927 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
5928 entry->toast_relfilenumber);
5929
5930 /* every toast table has an index */
5932 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5933 entry->toast_index_oid);
5935 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5936 entry->toast_index_relfilenumber);
5937 }
5938 }
5939 else
5940 {
5941 /* Preserve the OID and relfilenumber of the index */
5943 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5944 pg_class_oid);
5946 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5947 entry->relfilenumber);
5948 }
5949
5951}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), Assert, BinaryUpgradeClassOidItemCmp(), binaryUpgradeClassOids, fb(), nbinaryUpgradeClassOids, OidIsValid, BinaryUpgradeClassOidItem::relfilenumber, RelFileNumberIsValid, BinaryUpgradeClassOidItem::relkind, BinaryUpgradeClassOidItem::toast_index_oid, BinaryUpgradeClassOidItem::toast_index_relfilenumber, BinaryUpgradeClassOidItem::toast_oid, and BinaryUpgradeClassOidItem::toast_relfilenumber.
Referenced by dumpCompositeType(), dumpConstraint(), dumpIndex(), dumpSequence(), and dumpTableSchema().
◆ binary_upgrade_set_type_oids_by_rel()
|
static |
Definition at line 5806 of file pg_dump.c.
5809{
5811
5815}
References binary_upgrade_set_type_oids_by_type_oid(), fb(), and OidIsValid.
Referenced by dumpTableSchema().
◆ binary_upgrade_set_type_oids_by_type_oid()
|
static |
Definition at line 5726 of file pg_dump.c.
5731{
5733 PGresult *res;
5738
5741 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5742 pg_type_oid);
5743
5747 else
5749
5752
5754 {
5756 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5758 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5759 pg_type_array_oid);
5760 }
5761
5762 /*
5763 * Pre-set the multirange type oid and its own array type oid.
5764 */
5766 {
5768 {
5770 "SELECT t.oid, t.typarray "
5771 "FROM pg_catalog.pg_type t "
5772 "JOIN pg_catalog.pg_range r "
5773 "ON t.oid = r.rngmultitypid "
5774 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5775 pg_type_oid);
5776
5778
5781
5782 PQclear(res);
5783 }
5784 else
5785 {
5788 }
5789
5791 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5793 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5794 pg_type_multirange_oid);
5796 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5798 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5799 pg_type_multirange_array_oid);
5800 }
5801
5803}
References appendPQExpBuffer(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), findTypeByOid(), get_next_possible_free_pg_type_oid(), InvalidOid, OidIsValid, PQclear, PQfnumber(), PQgetvalue, printfPQExpBuffer(), and tinfo.
Referenced by binary_upgrade_set_type_oids_by_rel(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), dumpShellType(), and dumpUndefinedType().
◆ BinaryUpgradeClassOidItemCmp()
Definition at line 5821 of file pg_dump.c.
5822{
5825
5827}
References fb(), and pg_cmp_u32().
Referenced by binary_upgrade_set_pg_class_oids().
◆ BuildArchiveDependencies()
Definition at line 20497 of file pg_dump.c.
20498{
20500 TocEntry *te;
20501
20502 /* Scan all TOC entries in the archive */
20504 {
20505 DumpableObject *dobj;
20506 DumpId *dependencies;
20507 int nDeps;
20508 int allocDeps;
20509
20510 /* No need to process entries that will not be dumped */
20512 continue;
20513 /* Ignore entries that already have "special" dependencies */
20515 continue;
20516 /* Otherwise, look up the item's original DumpableObject, if any */
20519 continue;
20520 /* No work if it has no dependencies */
20522 continue;
20523 /* Set up work array */
20524 allocDeps = 64;
20526 nDeps = 0;
20527 /* Recursively find all dumpable dependencies */
20528 findDumpableDependencies(AH, dobj,
20529 &dependencies, &nDeps, &allocDeps);
20530 /* And save 'em ... */
20531 if (nDeps > 0)
20532 {
20535 te->dependencies = dependencies;
20536 te->nDeps = nDeps;
20537 }
20538 else
20539 free(dependencies);
20540 }
20541}
References _tocEntry::dependencies, _tocEntry::dumpId, fb(), findDumpableDependencies(), findObjectByDumpId(), free, _tocEntry::nDeps, _dumpableObject::nDeps, _tocEntry::next, pg_malloc(), pg_realloc(), _tocEntry::reqs, and _archiveHandle::toc.
Referenced by main().
◆ buildMatViewRefreshDependencies()
Definition at line 3140 of file pg_dump.c.
3141{
3142 PQExpBuffer query;
3143 PGresult *res;
3144 int ntups,
3145 i;
3147 i_objid,
3148 i_refobjid;
3149
3150 /* No Mat Views before 9.3. */
3152 return;
3153
3154 query = createPQExpBuffer();
3155
3157 "( "
3158 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3159 "FROM pg_depend d1 "
3160 "JOIN pg_class c1 ON c1.oid = d1.objid "
3162 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3163 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3164 "AND d2.objid = r1.oid "
3165 "AND d2.refobjid <> d1.objid "
3166 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3169 "WHERE d1.classid = 'pg_class'::regclass "
3170 "UNION "
3171 "SELECT w.objid, d3.refobjid, c3.relkind "
3172 "FROM w "
3173 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3174 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3175 "AND d3.objid = r3.oid "
3176 "AND d3.refobjid <> w.refobjid "
3177 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3180 ") "
3181 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3182 "FROM w "
3184
3186
3187 ntups = PQntuples(res);
3188
3192
3194 {
3195 CatalogId objId;
3197 DumpableObject *dobj;
3201
3206
3207 dobj = findObjectByCatalogId(objId);
3209 continue;
3210
3216 continue;
3218
3221 continue;
3222
3228 continue;
3230
3232
3235 }
3236
3237 PQclear(res);
3238
3239 destroyPQExpBuffer(query);
3240}
References addObjectDependency(), appendPQExpBufferStr(), Assert, atooid, CppAsString2, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_REFRESH_MATVIEW, DO_TABLE, _dumpableObject::dumpId, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), i, _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ checkExtensionMembership()
|
static |
Definition at line 1962 of file pg_dump.c.
1963{
1965
1967 return false;
1968
1970
1971 /* Record dependency so that getDependencies needn't deal with that */
1973
1974 /*
1975 * In 9.6 and above, mark the member object to have any non-initial ACLs
1976 * dumped. (Any initial ACLs will be removed later, using data from
1977 * pg_init_privs, so that we'll dump only the delta from the extension's
1978 * initial setup.)
1979 *
1980 * Prior to 9.6, we do not include any extension member components.
1981 *
1982 * In binary upgrades, we still dump all components of the members
1983 * individually, since the idea is to exactly reproduce the database
1984 * contents rather than replace the extension contents with something
1985 * different.
1986 *
1987 * Note: it might be interesting someday to implement storage and delta
1988 * dumping of extension members' RLS policies and/or security labels.
1989 * However there is a pitfall for RLS policies: trying to dump them
1990 * requires getting a lock on their tables, and the calling user might not
1991 * have privileges for that. We need no lock to examine a table's ACLs,
1992 * so the current feature doesn't have a problem of that sort.
1993 */
1996 else
1997 {
2000 else
2002 }
2003
2004 return true;
2005}
References addObjectDependency(), _dumpableObject::catId, _extensionInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_NONE, _dumpableObject::dump_contains, _dumpableObject::dumpId, _dumpableObject::ext_member, fb(), and findOwningExtension().
Referenced by selectDumpableAccessMethod(), selectDumpableCast(), selectDumpableNamespace(), selectDumpableObject(), selectDumpableProcLang(), selectDumpablePublicationObject(), selectDumpableStatisticsObject(), selectDumpableTable(), and selectDumpableType().
◆ collectBinaryUpgradeClassOids()
Definition at line 5837 of file pg_dump.c.
5838{
5839 PGresult *res;
5840 const char *query;
5841
5842 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5843 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5844 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5845 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5846 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5847 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5848 "ORDER BY c.oid;";
5849
5851
5855
5857 {
5865 }
5866
5867 PQclear(res);
5868}
References atooid, binaryUpgradeClassOids, ExecuteSqlQuery(), fb(), i, nbinaryUpgradeClassOids, BinaryUpgradeClassOidItem::oid, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, BinaryUpgradeClassOidItem::relfilenumber, BinaryUpgradeClassOidItem::relkind, BinaryUpgradeClassOidItem::toast_index_oid, BinaryUpgradeClassOidItem::toast_index_relfilenumber, BinaryUpgradeClassOidItem::toast_oid, and BinaryUpgradeClassOidItem::toast_relfilenumber.
Referenced by main().
◆ collectComments()
Definition at line 11593 of file pg_dump.c.
11594{
11595 PGresult *res;
11596 PQExpBuffer query;
11601 int ntups;
11603 DumpableObject *dobj;
11604
11605 query = createPQExpBuffer();
11606
11608 "FROM pg_catalog.pg_description "
11609 "ORDER BY classoid, objoid, objsubid");
11610
11612
11613 /* Construct lookup table containing OIDs in numeric form */
11614
11619
11620 ntups = PQntuples(res);
11621
11623 ncomments = 0;
11624 dobj = NULL;
11625
11627 {
11628 CatalogId objId;
11629 int subid;
11630
11634
11635 /* We needn't remember comments that don't match any dumpable object */
11639 dobj = findObjectByCatalogId(objId);
11641 continue;
11642
11643 /*
11644 * Comments on columns of composite types are linked to the type's
11645 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11646 * in the type's own DumpableObject.
11647 */
11650 {
11652
11656 }
11657 else
11658 dobj->components |= DUMP_COMPONENT_COMMENT;
11659
11664 ncomments++;
11665 }
11666
11667 PQclear(res);
11668 destroyPQExpBuffer(query);
11669}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, CommentItem::classoid, comments, createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_COMMENT, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), i, ncomments, CommentItem::objoid, CommentItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ collectRoleNames()
Definition at line 10733 of file pg_dump.c.
10734{
10735 PGresult *res;
10736 const char *query;
10738
10739 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10740
10742
10744
10746
10748 {
10751 }
10752
10753 PQclear(res);
10754}
References atooid, ExecuteSqlQuery(), fb(), i, nrolenames, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, RoleNameItem::rolename, rolenames, and RoleNameItem::roleoid.
Referenced by main().
◆ collectSecLabels()
Definition at line 16795 of file pg_dump.c.
16796{
16797 PGresult *res;
16798 PQExpBuffer query;
16804 int ntups;
16806 DumpableObject *dobj;
16807
16808 query = createPQExpBuffer();
16809
16810 appendPQExpBufferStr(query,
16811 "SELECT label, provider, classoid, objoid, objsubid "
16812 "FROM pg_catalog.pg_seclabels "
16813 "ORDER BY classoid, objoid, objsubid");
16814
16816
16817 /* Construct lookup table containing OIDs in numeric form */
16823
16824 ntups = PQntuples(res);
16825
16827 nseclabels = 0;
16828 dobj = NULL;
16829
16831 {
16832 CatalogId objId;
16833 int subid;
16834
16838
16839 /* We needn't remember labels that don't match any dumpable object */
16843 dobj = findObjectByCatalogId(objId);
16845 continue;
16846
16847 /*
16848 * Labels on columns of composite types are linked to the type's
16849 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16850 * in the type's own DumpableObject.
16851 */
16854 {
16856
16860 }
16861 else
16862 dobj->components |= DUMP_COMPONENT_SECLABEL;
16863
16869 nseclabels++;
16870 }
16871
16872 PQclear(res);
16873 destroyPQExpBuffer(query);
16874}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, SecLabelItem::classoid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_SECLABEL, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), i, SecLabelItem::label, nseclabels, SecLabelItem::objoid, SecLabelItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, SecLabelItem::provider, seclabels, and CatalogId::tableoid.
Referenced by main().
◆ collectSequences()
Definition at line 19132 of file pg_dump.c.
19133{
19134 PGresult *res;
19135 const char *query;
19136
19137 /*
19138 * Before Postgres 10, sequence metadata is in the sequence itself. With
19139 * some extra effort, we might be able to use the sorted table for those
19140 * versions, but for now it seems unlikely to be worth it.
19141 *
19142 * Since version 18, we can gather the sequence data in this query with
19143 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19144 */
19146 return;
19149 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19150 "seqstart, seqincrement, "
19151 "seqmax, seqmin, "
19152 "seqcache, seqcycle, "
19153 "NULL, 'f' "
19154 "FROM pg_catalog.pg_sequence "
19155 "ORDER BY seqrelid";
19156 else
19157 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19158 "seqstart, seqincrement, "
19159 "seqmax, seqmin, "
19160 "seqcache, seqcycle, "
19161 "last_value, is_called "
19162 "FROM pg_catalog.pg_sequence, "
19163 "pg_get_sequence_data(seqrelid) "
19164 "ORDER BY seqrelid;";
19165
19167
19170
19172 {
19184 }
19185
19186 PQclear(res);
19187}
References atooid, SequenceItem::cache, SequenceItem::cycled, ExecuteSqlQuery(), fb(), i, SequenceItem::incby, SequenceItem::is_called, SequenceItem::last_value, SequenceItem::maxv, SequenceItem::minv, nsequences, SequenceItem::null_seqtuple, SequenceItem::oid, parse_sequence_type(), pg_malloc(), PGRES_TUPLES_OK, PQclear, PQgetisnull, PQgetvalue, PQntuples, SequenceItem::seqtype, sequences, and SequenceItem::startv.
Referenced by main().
◆ convertRegProcReference()
◆ convertTSFunction()
Definition at line 14413 of file pg_dump.c.
14414{
14415 char *result;
14416 char query[128];
14417 PGresult *res;
14418
14420 "SELECT '%u'::pg_catalog.regproc", funcOid);
14422
14424
14425 PQclear(res);
14426
14427 return result;
14428}
References ExecuteSqlQueryForSingleRow(), fb(), pg_strdup(), PQclear, PQgetvalue, and snprintf.
Referenced by dumpTSParser(), and dumpTSTemplate().
◆ createBoundaryObjects()
|
static |
Definition at line 20347 of file pg_dump.c.
20348{
20350
20352
20357
20362
20364}
References AssignDumpId(), DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, fb(), nilCatalogId, _dumpableObject::objType, pg_malloc(), and pg_strdup().
Referenced by main().
◆ createDummyViewAsClause()
|
static |
Definition at line 17070 of file pg_dump.c.
17071{
17074
17076
17078 {
17082
17084
17085 /*
17086 * Must add collation if not default for the type, because CREATE OR
17087 * REPLACE VIEW won't change it
17088 */
17090 {
17092
17097 }
17098
17100 }
17101
17102 return result;
17103}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, j, and OidIsValid.
Referenced by dumpRule(), and dumpTableSchema().
◆ createViewAsClause()
|
static |
Definition at line 17021 of file pg_dump.c.
17022{
17025 PGresult *res;
17027
17028 /* Fetch the view definition */
17029 appendPQExpBuffer(query,
17030 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
17031 tbinfo->dobj.catId.oid);
17032
17034
17036 {
17039 tbinfo->dobj.name);
17040 else
17042 tbinfo->dobj.name);
17043 }
17044
17046
17049 tbinfo->dobj.name);
17050
17051 /* Strip off the trailing semicolon so that other things may follow. */
17054
17055 PQclear(res);
17056 destroyPQExpBuffer(query);
17057
17058 return result;
17059}
References appendBinaryPQExpBuffer(), appendPQExpBuffer(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), len, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetlength, PQgetvalue, and PQntuples.
Referenced by dumpRule(), and dumpTableSchema().
◆ determineNotNullFlags()
|
static |
Definition at line 10028 of file pg_dump.c.
10036{
10038
10039 /*
10040 * If this not-null constraint is not valid, list its OID in
10041 * invalidnotnulloids and do nothing further. It'll be processed
10042 * elsewhere later.
10043 *
10044 * Because invalid not-null constraints are rare, we don't want to malloc
10045 * invalidnotnulloids until we're sure we're going it need it, which
10046 * happens here.
10047 */
10049 {
10051
10053 {
10057 }
10058 else
10060
10061 /*
10062 * Track when a parent constraint is invalid for the cases where a
10063 * child constraint has been validated independenly.
10064 */
10066
10067 /* nothing else to do */
10069 return;
10070 }
10071
10072 /*
10073 * notnull_noinh is straight from the query result. notnull_islocal also,
10074 * though flagInhAttrs may change that one later.
10075 */
10079
10080 /*
10081 * Determine a constraint name to use. If the column is not marked not-
10082 * null, we set NULL which cues ... to do nothing. An empty string says
10083 * to print an unnamed NOT NULL, and anything else is a constraint name to
10084 * use.
10085 */
10087 {
10088 /*
10089 * < 18 doesn't have not-null names, so an unnamed constraint is
10090 * sufficient.
10091 */
10094 else
10096 }
10097 else
10098 {
10101 else
10102 {
10103 /*
10104 * In binary upgrade of inheritance child tables, must have a
10105 * constraint name that we can UPDATE later; same if there's a
10106 * comment on the constraint.
10107 */
10109 !tbinfo->ispartition &&
10110 !tbinfo->notnull_islocal) ||
10112 {
10115 }
10116 else
10117 {
10119
10120 /* XXX should match ChooseConstraintName better */
10126 else
10127 {
10130 }
10132 }
10133 }
10134 }
10135}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _dumpOptions::binary_upgrade, createPQExpBuffer(), fb(), free, j, PQgetisnull, PQgetvalue, psprintf(), and pstrdup().
Referenced by getTableAttrs().
◆ dumpAccessMethod()
|
static |
Definition at line 14435 of file pg_dump.c.
14436{
14438 PQExpBuffer q;
14441
14442 /* Do nothing if not dumping schema */
14444 return;
14445
14446 q = createPQExpBuffer();
14448
14450
14452
14454 {
14457 break;
14460 break;
14461 default:
14464 destroyPQExpBuffer(q);
14467 return;
14468 }
14469
14471
14473 qamname);
14474
14478
14482 .description = "ACCESS METHOD",
14483 .section = SECTION_PRE_DATA,
14484 .createStmt = q->data,
14485 .dropStmt = delq->data));
14486
14487 /* Dump Access Method Comments */
14492
14493 destroyPQExpBuffer(q);
14496}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), free, pg_log_warning, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpACL()
|
static |
Definition at line 16426 of file pg_dump.c.
16430{
16438 PQExpBuffer sql;
16439
16440 /* Do nothing if ACL dump is not enabled */
16443
16444 /* --data-only skips ACLs *except* large object ACLs */
16447
16448 sql = createPQExpBuffer();
16449
16450 /*
16451 * In binary upgrade mode, we don't run an extension's script but instead
16452 * dump out the objects independently and then recreate them. To preserve
16453 * any initial privileges which were set on extension objects, we need to
16454 * compute the set of GRANT and REVOKE commands necessary to get from the
16455 * default privileges of an object to its initial privileges as recorded
16456 * in pg_init_privs.
16457 *
16458 * At restore time, we apply these commands after having called
16459 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16460 * copy the results into pg_init_privs. This is how we preserve the
16461 * contents of that catalog across binary upgrades.
16462 */
16464 initprivs && *initprivs != '\0')
16465 {
16468 initprivs, acldefault, owner,
16472 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16473 }
16474
16475 /*
16476 * Now figure the GRANT and REVOKE commands needed to get to the object's
16477 * actual current ACL, starting from the initprivs if given, else from the
16478 * object-type-specific default. Also, while buildACLCommands will assume
16479 * that a NULL/empty acls string means it needn't do anything, what that
16480 * actually represents is the object-type-specific default; so we need to
16481 * substitute the acldefault string to get the right results in that case.
16482 */
16483 if (initprivs && *initprivs != '\0')
16484 {
16485 baseacls = initprivs;
16488 }
16489 else
16491
16497
16499 {
16502 int nDeps = 0;
16503
16504 if (tag)
16508 else
16510
16514
16516
16519 .namespace = nspname,
16520 .owner = owner,
16521 .description = "ACL",
16522 .section = SECTION_NONE,
16523 .createStmt = sql->data,
16524 .deps = aclDeps,
16525 .nDeps = nDeps));
16526
16528 }
16529
16530 destroyPQExpBuffer(sql);
16531
16533}
References _dumpableAcl::acl, acldefault(), _dumpableAcl::acldefault, _dumpOptions::aclsSkip, appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, buildACLCommands(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpSchema, fb(), _dumpableAcl::initprivs, InvalidDumpId, PQExpBufferData::len, name, nilCatalogId, pg_fatal, _dumpableAcl::privtype, SECTION_NONE, subname, and type.
Referenced by dumpAgg(), dumpBaseType(), dumpCompositeType(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpLO(), dumpNamespace(), dumpProcLang(), dumpRangeType(), dumpTable(), and dumpUndefinedType().
◆ dumpAgg()
Definition at line 15388 of file pg_dump.c.
15389{
15391 PQExpBuffer query;
15392 PQExpBuffer q;
15394 PQExpBuffer details;
15398 PGresult *res;
15413 const char *aggsortop;
15416 const char *aggtranstype;
15417 const char *aggtransspace;
15424
15425 /* Do nothing if not dumping schema */
15427 return;
15428
15429 query = createPQExpBuffer();
15430 q = createPQExpBuffer();
15432 details = createPQExpBuffer();
15433
15435 {
15436 /* Set up query for aggregate-specific details */
15437 appendPQExpBufferStr(query,
15438 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15439
15440 appendPQExpBufferStr(query,
15441 "SELECT "
15442 "aggtransfn,\n"
15443 "aggfinalfn,\n"
15444 "aggtranstype::pg_catalog.regtype,\n"
15445 "agginitval,\n"
15446 "aggsortop,\n"
15447 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15448 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15449
15451 appendPQExpBufferStr(query,
15452 "aggkind,\n"
15453 "aggmtransfn,\n"
15454 "aggminvtransfn,\n"
15455 "aggmfinalfn,\n"
15456 "aggmtranstype::pg_catalog.regtype,\n"
15457 "aggfinalextra,\n"
15458 "aggmfinalextra,\n"
15459 "aggtransspace,\n"
15460 "aggmtransspace,\n"
15461 "aggminitval,\n");
15462 else
15463 appendPQExpBufferStr(query,
15464 "'n' AS aggkind,\n"
15465 "'-' AS aggmtransfn,\n"
15466 "'-' AS aggminvtransfn,\n"
15467 "'-' AS aggmfinalfn,\n"
15468 "0 AS aggmtranstype,\n"
15469 "false AS aggfinalextra,\n"
15470 "false AS aggmfinalextra,\n"
15471 "0 AS aggtransspace,\n"
15472 "0 AS aggmtransspace,\n"
15473 "NULL AS aggminitval,\n");
15474
15476 appendPQExpBufferStr(query,
15477 "aggcombinefn,\n"
15478 "aggserialfn,\n"
15479 "aggdeserialfn,\n"
15480 "proparallel,\n");
15481 else
15482 appendPQExpBufferStr(query,
15483 "'-' AS aggcombinefn,\n"
15484 "'-' AS aggserialfn,\n"
15485 "'-' AS aggdeserialfn,\n"
15486 "'u' AS proparallel,\n");
15487
15489 appendPQExpBufferStr(query,
15490 "aggfinalmodify,\n"
15491 "aggmfinalmodify\n");
15492 else
15493 appendPQExpBufferStr(query,
15494 "'0' AS aggfinalmodify,\n"
15495 "'0' AS aggmfinalmodify\n");
15496
15497 appendPQExpBufferStr(query,
15498 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15499 "WHERE a.aggfnoid = p.oid "
15500 "AND p.oid = $1");
15501
15503
15505 }
15506
15507 printfPQExpBuffer(query,
15508 "EXECUTE dumpAgg('%u')",
15509 agginfo->aggfn.dobj.catId.oid);
15510
15512
15515
15537
15538 {
15541
15546 }
15547
15549
15550 /* identify default modify flag for aggkind (must match DefineAggregate) */
15551 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
15552 /* replace omitted flags for old versions */
15557
15558 /* regproc and regtype output is already sufficiently quoted */
15560 aggtransfn, aggtranstype);
15561
15563 {
15565 aggtransspace);
15566 }
15567
15569 {
15572 }
15573
15575 {
15577 aggfinalfn);
15581 {
15583 {
15586 break;
15589 break;
15592 break;
15593 default:
15595 agginfo->aggfn.dobj.name);
15596 break;
15597 }
15598 }
15599 }
15600
15603
15606
15609
15611 {
15613 aggmtransfn,
15614 aggminvtransfn,
15615 aggmtranstype);
15616 }
15617
15619 {
15621 aggmtransspace);
15622 }
15623
15625 {
15628 }
15629
15631 {
15633 aggmfinalfn);
15637 {
15639 {
15642 break;
15645 break;
15648 break;
15649 default:
15651 agginfo->aggfn.dobj.name);
15652 break;
15653 }
15654 }
15655 }
15656
15659 {
15661 aggsortconvop);
15663 }
15664
15667
15669 {
15676 agginfo->aggfn.dobj.name);
15677 }
15678
15681 aggsig);
15682
15686
15690 agginfo->aggfn.dobj.namespace->dobj.name);
15691
15694 agginfo->aggfn.dobj.dumpId,
15697 .owner = agginfo->aggfn.rolname,
15698 .description = "AGGREGATE",
15699 .section = SECTION_PRE_DATA,
15700 .createStmt = q->data,
15701 .dropStmt = delq->data));
15702
15703 /* Dump Aggregate Comments */
15706 agginfo->aggfn.dobj.namespace->dobj.name,
15707 agginfo->aggfn.rolname,
15709
15712 agginfo->aggfn.dobj.namespace->dobj.name,
15713 agginfo->aggfn.rolname,
15715
15716 /*
15717 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
15718 * command look like a function's GRANT; in particular this affects the
15719 * syntax for zero-argument aggregates and ordered-set aggregates.
15720 */
15722
15724
15728 agginfo->aggfn.dobj.namespace->dobj.name,
15730
15734
15735 PQclear(res);
15736
15737 destroyPQExpBuffer(query);
15738 destroyPQExpBuffer(q);
15740 destroyPQExpBuffer(details);
15741}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), _dumpOptions::dumpSchema, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtId(), format_aggregate_signature(), format_function_arguments(), format_function_signature(), free, getFormattedOperatorName(), InvalidDumpId, pg_fatal, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPAGG, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpAttrDef()
|
static |
Definition at line 18193 of file pg_dump.c.
18194{
18198 PQExpBuffer q;
18201 char *tag;
18203
18204 /* Do nothing if not dumping schema */
18206 return;
18207
18208 /* Skip if not "separate"; it was dumped in the table's definition */
18210 return;
18211
18212 q = createPQExpBuffer();
18214
18216
18218
18219 appendPQExpBuffer(q,
18220 "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
18222 adinfo->adef_expr);
18223
18227
18229
18232 ARCHIVE_OPTS(.tag = tag,
18234 .owner = tbinfo->rolname,
18235 .description = "DEFAULT",
18236 .section = SECTION_PRE_DATA,
18237 .createStmt = q->data,
18238 .dropStmt = delq->data));
18239
18240 free(tag);
18241 destroyPQExpBuffer(q);
18244}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, pg_strdup(), psprintf(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpBaseType()
Definition at line 12468 of file pg_dump.c.
12469{
12474 PGresult *res;
12477 char *typlen;
12479 char *typoutput;
12480 char *typreceive;
12481 char *typsend;
12485 char *typsubscript;
12494 char *typdelim;
12495 char *typbyval;
12497 char *typstorage;
12501
12503 {
12504 /* Set up query for type-specific details */
12505 appendPQExpBufferStr(query,
12506 "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
12507 "SELECT typlen, "
12508 "typinput, typoutput, typreceive, typsend, "
12509 "typreceive::pg_catalog.oid AS typreceiveoid, "
12510 "typsend::pg_catalog.oid AS typsendoid, "
12511 "typanalyze, "
12512 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
12513 "typdelim, typbyval, typalign, typstorage, "
12514 "typmodin, typmodout, "
12515 "typmodin::pg_catalog.oid AS typmodinoid, "
12516 "typmodout::pg_catalog.oid AS typmodoutoid, "
12517 "typcategory, typispreferred, "
12518 "(typcollation <> 0) AS typcollatable, "
12519 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
12520
12522 appendPQExpBufferStr(query,
12523 "typsubscript, "
12524 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
12525 else
12526 appendPQExpBufferStr(query,
12527 "'-' AS typsubscript, 0 AS typsubscriptoid ");
12528
12530 "WHERE oid = $1");
12531
12533
12535 }
12536
12537 printfPQExpBuffer(query,
12538 "EXECUTE dumpBaseType('%u')",
12539 tyinfo->dobj.catId.oid);
12540
12542
12568 {
12571 }
12572 else
12574
12577
12578 /*
12579 * The reason we include CASCADE is that the circular dependency between
12580 * the type and its I/O functions makes it impossible to drop the type any
12581 * other way.
12582 */
12584
12585 /*
12586 * We might already have a shell type, but setting pg_type_oid is
12587 * harmless, and in any case we'd better set the array type OID.
12588 */
12591 tyinfo->dobj.catId.oid,
12592 false, false);
12593
12594 appendPQExpBuffer(q,
12595 "CREATE TYPE %s (\n"
12596 " INTERNALLENGTH = %s",
12597 qualtypname,
12599
12600 /* regproc result is sufficiently quoted already */
12613
12616
12618 {
12622 else
12624 }
12625
12628
12632 zeroIsError));
12633
12635 {
12638 }
12639
12642
12644 {
12647 }
12648
12657
12666
12669
12671
12675 tyinfo->dobj.namespace->dobj.name);
12676
12680 .namespace = tyinfo->dobj.namespace->dobj.name,
12681 .owner = tyinfo->rolname,
12682 .description = "TYPE",
12683 .section = SECTION_PRE_DATA,
12684 .createStmt = q->data,
12685 .dropStmt = delq->data));
12686
12687 /* Dump Type Comments and Security Labels */
12692
12697
12701 tyinfo->dobj.namespace->dobj.name,
12703
12704 PQclear(res);
12705 destroyPQExpBuffer(q);
12707 destroyPQExpBuffer(query);
12710}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtId(), fmtQualifiedDumpable, free, getFormattedTypeName(), InvalidDumpId, OidIsValid, pg_strdup(), PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPBASETYPE, printfPQExpBuffer(), SECTION_PRE_DATA, typalign, and zeroIsError.
Referenced by dumpType().
◆ dumpCast()
Definition at line 13889 of file pg_dump.c.
13890{
13899
13900 /* Do nothing if not dumping schema */
13902 return;
13903
13904 /* Cannot dump if we don't have the cast function's info */
13906 {
13910 cast->castfunc);
13911 }
13912
13917
13922
13925
13927 {
13930 break;
13933 break;
13936 {
13938
13939 /*
13940 * Always qualify the function name (format_function_signature
13941 * won't qualify it).
13942 */
13946 }
13947 else
13949 break;
13950 default:
13952 }
13953
13959
13962
13965
13969
13973 .description = "CAST",
13974 .section = SECTION_PRE_DATA,
13975 .createStmt = defqry->data,
13976 .dropStmt = delqry->data));
13977
13978 /* Dump Cast Comments */
13983
13988}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), findFuncByOid(), fmtId(), format_function_signature(), free, getFormattedTypeName(), OidIsValid, pg_fatal, pg_log_warning, SECTION_PRE_DATA, and zeroAsNone.
Referenced by dumpDumpableObject().
◆ dumpCollation()
Definition at line 15003 of file pg_dump.c.
15004{
15006 PQExpBuffer query;
15007 PQExpBuffer q;
15010 PGresult *res;
15022
15023 /* Do nothing if not dumping schema */
15025 return;
15026
15027 query = createPQExpBuffer();
15028 q = createPQExpBuffer();
15030
15032
15033 /* Get collation-specific details */
15035
15037 appendPQExpBufferStr(query,
15038 "collprovider, "
15039 "collversion, ");
15040 else
15041 appendPQExpBufferStr(query,
15042 "'c' AS collprovider, "
15043 "NULL AS collversion, ");
15044
15046 appendPQExpBufferStr(query,
15047 "collisdeterministic, ");
15048 else
15049 appendPQExpBufferStr(query,
15050 "true AS collisdeterministic, ");
15051
15053 appendPQExpBufferStr(query,
15054 "colllocale, ");
15056 appendPQExpBufferStr(query,
15057 "colliculocale AS colllocale, ");
15058 else
15059 appendPQExpBufferStr(query,
15060 "NULL AS colllocale, ");
15061
15063 appendPQExpBufferStr(query,
15064 "collicurules, ");
15065 else
15066 appendPQExpBufferStr(query,
15067 "NULL AS collicurules, ");
15068
15069 appendPQExpBuffer(query,
15070 "collcollate, "
15071 "collctype "
15072 "FROM pg_catalog.pg_collation c "
15073 "WHERE c.oid = '%u'::pg_catalog.oid",
15074 collinfo->dobj.catId.oid);
15075
15077
15084
15086
15089 else
15091
15094 else
15096
15097 /*
15098 * Before version 15, collcollate and collctype were of type NAME and
15099 * non-nullable. Treat empty strings as NULL for consistency.
15100 */
15102 {
15107 }
15108
15111 else
15113
15116 else
15118
15121
15124
15133 /* to allow dumping pg_catalog; not accepted on input */
15135 else
15137 collprovider);
15138
15141
15143 {
15146
15147 /* no locale -- the default collation cannot be reloaded anyway */
15148 }
15150 {
15153
15156 fout);
15157 }
15159 {
15161 {
15164
15167 fout);
15168 }
15169 else
15170 {
15174
15177 }
15178
15180 {
15183 }
15184 }
15186 {
15189
15191 {
15194 }
15195 else
15196 {
15201 }
15202 }
15203 else
15205
15206 /*
15207 * For binary upgrade, carry over the collation version. For normal
15208 * dump/restore, omit the version, so that it is computed upon restore.
15209 */
15211 {
15213
15216 {
15218 appendStringLiteralAH(q,
15220 fout);
15221 }
15222 }
15223
15225
15229 collinfo->dobj.namespace->dobj.name);
15230
15234 .namespace = collinfo->dobj.namespace->dobj.name,
15235 .owner = collinfo->rolname,
15236 .description = "COLLATION",
15237 .section = SECTION_PRE_DATA,
15238 .createStmt = q->data,
15239 .dropStmt = delq->data));
15240
15241 /* Dump Collation Comments */
15246
15247 PQclear(res);
15248
15249 destroyPQExpBuffer(query);
15250 destroyPQExpBuffer(q);
15253}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, pg_fatal, pg_log_warning, pg_strdup(), PQclear, PQfnumber(), PQgetisnull, PQgetvalue, and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpComment()
|
inlinestatic |
Definition at line 10997 of file pg_dump.c.
References dumpCommentExtended(), fb(), name, and type.
Referenced by dumpAccessMethod(), dumpAgg(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConstraint(), dumpConversion(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpLO(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpRangeType(), dumpRule(), dumpSequence(), dumpStatisticsExt(), dumpSubscription(), dumpTableConstraintComment(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), and dumpUndefinedType().
◆ dumpCommentExtended()
|
static |
Definition at line 10897 of file pg_dump.c.
10902{
10906
10907 /* do nothing, if --no-comments is supplied */
10909 return;
10910
10911 /* Comments are schema not data ... except LO comments are data */
10913 {
10915 return;
10916 }
10917 else
10918 {
10919 /* We do dump LO comments in binary-upgrade mode */
10921 return;
10922 }
10923
10924 /* Search for comments associated with catalogId, using table */
10926 &comments);
10927
10928 /* Is there one matching the subid? */
10930 {
10932 break;
10933 comments++;
10934 ncomments--;
10935 }
10936
10938 {
10940
10941 /*
10942 * initdb creates this object with a comment. Skip dumping the
10943 * initdb-provided comment, which would complicate matters for
10944 * non-superuser use of pg_dump. When the DBA has removed initdb's
10945 * comment, replicate that.
10946 */
10948 {
10950 ncomments = 1;
10951 }
10953 ncomments = 0;
10954 }
10955
10956 /* If a comment exists, build COMMENT ON statement */
10958 {
10961
10963 if (namespace && *namespace)
10968
10970
10971 /*
10972 * We mark comments as SECTION_NONE because they really belong in the
10973 * same section as their parent, whether that is pre-data or
10974 * post-data.
10975 */
10978 .namespace = namespace,
10979 .owner = owner,
10980 .description = "COMMENT",
10981 .section = SECTION_NONE,
10982 .createStmt = query->data,
10983 .deps = &dumpId,
10984 .nDeps = 1));
10985
10986 destroyPQExpBuffer(query);
10987 destroyPQExpBuffer(tag);
10988 }
10989}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, comments, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), _dumpOptions::dumpData, _dumpOptions::dumpSchema, fb(), findComments(), fmtId(), name, ncomments, nilCatalogId, _dumpOptions::no_comments, CommentItem::objsubid, CatalogId::oid, SECTION_NONE, CatalogId::tableoid, and type.
Referenced by dumpComment(), and dumpNamespace().
◆ dumpCompositeType()
Definition at line 12942 of file pg_dump.c.
12943{
12949 PGresult *res;
12952 int ntups;
12961
12963 {
12964 /*
12965 * Set up query for type-specific details.
12966 *
12967 * Since we only want to dump COLLATE clauses for attributes whose
12968 * collation is different from their type's default, we use a CASE
12969 * here to suppress uninteresting attcollations cheaply. atttypid
12970 * will be 0 for dropped columns; collation does not matter for those.
12971 */
12972 appendPQExpBufferStr(query,
12973 "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
12974 "SELECT a.attname, a.attnum, "
12975 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
12976 "a.attlen, a.attalign, a.attisdropped, "
12977 "CASE WHEN a.attcollation <> at.typcollation "
12978 "THEN a.attcollation ELSE 0 END AS attcollation "
12979 "FROM pg_catalog.pg_type ct "
12980 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
12981 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
12982 "WHERE ct.oid = $1 "
12983 "ORDER BY a.attnum");
12984
12986
12988 }
12989
12990 printfPQExpBuffer(query,
12991 "EXECUTE dumpCompositeType('%u')",
12992 tyinfo->dobj.catId.oid);
12993
12995
12996 ntups = PQntuples(res);
12997
13004
13006 {
13008 tyinfo->dobj.catId.oid,
13009 false, false);
13011 }
13012
13015
13017 qualtypname);
13018
13019 actual_atts = 0;
13021 {
13026 bool attisdropped;
13027 Oid attcollation;
13028
13035
13037 continue;
13038
13039 /* Format properly if not first attr */
13043
13044 if (!attisdropped)
13045 {
13047
13048 /* Add collation if not default for the column type */
13050 {
13052
13057 }
13058 }
13059 else
13060 {
13061 /*
13062 * This is a dropped attribute and we're in binary_upgrade mode.
13063 * Insert a placeholder for it in the CREATE TYPE command, and set
13064 * length and alignment with direct UPDATE to the catalogs
13065 * afterwards. See similar code in dumpTableSchema().
13066 */
13068
13069 /* stash separately for insertion after the CREATE TYPE */
13070 appendPQExpBufferStr(dropped,
13071 "\n-- For binary upgrade, recreate dropped column.\n");
13073 "SET attlen = %s, "
13074 "attalign = '%s', attbyval = false\n"
13080
13082 qualtypname);
13085 }
13086 }
13089
13091
13095 tyinfo->dobj.namespace->dobj.name);
13096
13100 .namespace = tyinfo->dobj.namespace->dobj.name,
13101 .owner = tyinfo->rolname,
13102 .description = "TYPE",
13103 .section = SECTION_PRE_DATA,
13104 .createStmt = q->data,
13105 .dropStmt = delq->data));
13106
13107
13108 /* Dump Type Comments and Security Labels */
13113
13118
13122 tyinfo->dobj.namespace->dobj.name,
13124
13125 /* Dump any per-column comments */
13128
13129 PQclear(res);
13130 destroyPQExpBuffer(q);
13131 destroyPQExpBuffer(dropped);
13133 destroyPQExpBuffer(query);
13136}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, attalign, attlen, attname, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpCompositeTypeColComments(), dumpSecLabel(), ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, free, i, InvalidDumpId, OidIsValid, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, PREPQUERY_DUMPCOMPOSITETYPE, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpType().
◆ dumpCompositeTypeColComments()
|
static |
Definition at line 13148 of file pg_dump.c.
13150{
13153 PQExpBuffer query;
13154 PQExpBuffer target;
13156 int ntups;
13160
13161 /* do nothing, if --no-comments is supplied */
13163 return;
13164
13165 /* Search for comments associated with type's pg_class OID */
13167 &comments);
13168
13169 /* If no comments exist, we're done */
13171 return;
13172
13173 /* Build COMMENT ON statements */
13174 query = createPQExpBuffer();
13175 target = createPQExpBuffer();
13176
13177 ntups = PQntuples(res);
13182 {
13184
13187 {
13190 {
13192 break;
13193 }
13194 }
13196 {
13198
13199 resetPQExpBuffer(target);
13203
13204 resetPQExpBuffer(query);
13210
13213 .namespace = tyinfo->dobj.namespace->dobj.name,
13214 .owner = tyinfo->rolname,
13215 .description = "COMMENT",
13216 .section = SECTION_NONE,
13217 .createStmt = query->data,
13218 .deps = &(tyinfo->dobj.dumpId),
13219 .nDeps = 1));
13220 }
13221
13222 comments++;
13223 ncomments--;
13224 }
13225
13226 destroyPQExpBuffer(query);
13227 destroyPQExpBuffer(target);
13228}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), attname, comments, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), fb(), findComments(), fmtId(), fmtQualifiedDumpable, i, ncomments, nilCatalogId, CommentItem::objsubid, PQfnumber(), PQgetvalue, PQntuples, resetPQExpBuffer(), and SECTION_NONE.
Referenced by dumpCompositeType().
◆ dumpConstraint()
|
static |
Definition at line 18757 of file pg_dump.c.
18758{
18761 PQExpBuffer q;
18765
18766 /* Do nothing if not dumping schema */
18768 return;
18769
18770 q = createPQExpBuffer();
18772
18775
18779 {
18780 /* Index-related constraint */
18782 int k;
18783
18785
18788 coninfo->dobj.name);
18789
18792 indxinfo->dobj.catId.oid);
18793
18798
18800 {
18801 /* pg_get_constraintdef should have provided everything */
18803 }
18804 else
18805 {
18806 appendPQExpBufferStr(q,
18808
18809 /*
18810 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
18811 * indexes. Being able to create this was fixed, but we need to
18812 * make the index distinct in order to be able to restore the
18813 * dump.
18814 */
18819 {
18822
18824 break;
18826
18828 (k == 0) ? "" : ", ",
18830 }
18833
18836
18838 {
18841
18843 break;
18845
18849 }
18850
18852
18854 {
18858 }
18859
18861 {
18865 }
18866
18868 }
18869
18870 /*
18871 * Append ALTER TABLE commands as needed to set properties that we
18872 * only have ALTER TABLE syntax for. Keep this in sync with the
18873 * similar code in dumpIndex!
18874 */
18875
18876 /* If the index is clustered, we need to record that. */
18878 {
18881 /* index name is not qualified in this syntax */
18884 }
18885
18886 /* If the index defines identity, we need to record that. */
18888 {
18891 /* index name is not qualified in this syntax */
18894 }
18895
18896 /* Indexes can depend on extensions */
18898 "pg_catalog.pg_class", "INDEX",
18900
18905
18907
18910 ARCHIVE_OPTS(.tag = tag,
18912 .tablespace = indxinfo->tablespace,
18913 .owner = tbinfo->rolname,
18914 .description = "CONSTRAINT",
18915 .section = SECTION_POST_DATA,
18916 .createStmt = q->data,
18917 .dropStmt = delq->data));
18918 }
18920 {
18922
18923 /*
18924 * Foreign keys on partitioned tables are always declared as
18925 * inheriting to partitions; for all other cases, emit them as
18926 * applying ONLY directly to the named table, because that's how they
18927 * work for regular inherited tables.
18928 */
18930
18931 /*
18932 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
18933 * current table data is not processed
18934 */
18939 coninfo->condef);
18940
18945
18947
18950 ARCHIVE_OPTS(.tag = tag,
18952 .owner = tbinfo->rolname,
18953 .description = "FK CONSTRAINT",
18954 .section = SECTION_POST_DATA,
18955 .createStmt = q->data,
18956 .dropStmt = delq->data));
18957 }
18959 {
18960 /* CHECK or invalid not-null constraint on a table */
18961
18962 /* Ignore if not to be dumped separately, or if it was inherited */
18964 {
18965 const char *keyword;
18966
18968 keyword = "CHECK CONSTRAINT";
18969 else
18970 keyword = "CONSTRAINT";
18971
18972 /* not ONLY since we want it to propagate to children */
18977 coninfo->condef);
18978
18983
18985
18988 ARCHIVE_OPTS(.tag = tag,
18990 .owner = tbinfo->rolname,
18991 .description = keyword,
18992 .section = SECTION_POST_DATA,
18993 .createStmt = q->data,
18994 .dropStmt = delq->data));
18995 }
18996 }
18998 {
18999 /* CHECK, NOT NULL constraint on a domain */
19001
19003
19004 /* Ignore if not to be dumped separately */
19006 {
19007 const char *keyword;
19008
19010 keyword = "CHECK CONSTRAINT";
19011 else
19012 keyword = "CONSTRAINT";
19013
19018 coninfo->condef);
19019
19024
19026
19029 ARCHIVE_OPTS(.tag = tag,
19031 .owner = tyinfo->rolname,
19032 .description = keyword,
19033 .section = SECTION_POST_DATA,
19034 .createStmt = q->data,
19035 .dropStmt = delq->data));
19036
19038 {
19041
19044
19046 tyinfo->dobj.namespace->dobj.name,
19047 tyinfo->rolname,
19051 }
19052 }
19053 }
19054 else
19055 {
19057 coninfo->contype);
19058 }
19059
19060 /* Dump Constraint Comments --- only works for table constraints */
19064
19065 free(tag);
19066 destroyPQExpBuffer(q);
19068}
References append_depends_on_extension(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendReloptionsArrayAH(), ARCHIVE_OPTS, ArchiveEntry(), Assert, attname, _dumpOptions::binary_upgrade, binary_upgrade_set_pg_class_oids(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, dumpTableConstraintComment(), fb(), findObjectByDumpId(), fmtId(), fmtQualifiedDumpable, free, getAttrName(), InvalidAttrNumber, nonemptyReloptions(), pg_fatal, pg_strdup(), psprintf(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpConversion()
Definition at line 15260 of file pg_dump.c.
15261{
15263 PQExpBuffer query;
15264 PQExpBuffer q;
15267 PGresult *res;
15276
15277 /* Do nothing if not dumping schema */
15279 return;
15280
15281 query = createPQExpBuffer();
15282 q = createPQExpBuffer();
15284
15286
15287 /* Get conversion-specific details */
15289 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
15290 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
15291 "conproc, condefault "
15292 "FROM pg_catalog.pg_conversion c "
15293 "WHERE c.oid = '%u'::pg_catalog.oid",
15294 convinfo->dobj.catId.oid);
15295
15297
15302
15307
15310
15317 /* regproc output is already sufficiently quoted */
15319
15323 convinfo->dobj.namespace->dobj.name);
15324
15328 .namespace = convinfo->dobj.namespace->dobj.name,
15329 .owner = convinfo->rolname,
15330 .description = "CONVERSION",
15331 .section = SECTION_PRE_DATA,
15332 .createStmt = q->data,
15333 .dropStmt = delq->data));
15334
15335 /* Dump Conversion Comments */
15340
15341 PQclear(res);
15342
15343 destroyPQExpBuffer(query);
15344 destroyPQExpBuffer(q);
15347}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, pg_strdup(), PQclear, PQfnumber(), PQgetvalue, and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpDatabase()
Definition at line 3296 of file pg_dump.c.
3297{
3304 PGresult *res;
3306 i_oid,
3307 i_datname,
3308 i_datdba,
3309 i_encoding,
3310 i_datlocprovider,
3311 i_collate,
3312 i_ctype,
3313 i_datlocale,
3314 i_daticurules,
3315 i_frozenxid,
3316 i_minmxid,
3317 i_datacl,
3318 i_acldefault,
3319 i_datistemplate,
3320 i_datconnlimit,
3321 i_datcollversion,
3322 i_tablespace;
3327 *dba,
3328 *encoding,
3329 *datlocprovider,
3330 *collate,
3331 *ctype,
3332 *locale,
3333 *icurules,
3334 *datistemplate,
3335 *datconnlimit,
3336 *tablespace;
3337 uint32 frozenxid,
3338 minmxid;
3340
3342
3343 /*
3344 * Fetch the database-level properties for this database.
3345 */
3347 "datdba, "
3348 "pg_encoding_to_char(encoding) AS encoding, "
3349 "datcollate, datctype, datfrozenxid, "
3350 "datacl, acldefault('d', datdba) AS acldefault, "
3351 "datistemplate, datconnlimit, ");
3354 else
3360 else
3361 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
3364 else
3367 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3368 "shobj_description(oid, 'pg_database') AS description "
3369 "FROM pg_database "
3370 "WHERE datname = current_database()");
3371
3373
3392
3403 else
3404 locale = NULL;
3407 else
3416
3418
3419 /*
3420 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3421 * to preserve that), as well as the encoding, locale, and tablespace
3422 * since those can't be altered later. Other DB properties are left to
3423 * the DATABASE PROPERTIES entry, so that they can be applied after
3424 * reconnecting to the target DB.
3425 *
3426 * For binary upgrade, we use the FILE_COPY strategy because testing has
3427 * shown it to be faster. When the server is in binary upgrade mode, it
3428 * will also skip the checkpoints this strategy ordinarily performs.
3429 */
3431 {
3433 "CREATE DATABASE %s WITH TEMPLATE = template0 "
3434 "OID = %u STRATEGY = FILE_COPY",
3436 }
3437 else
3438 {
3440 qdatname);
3441 }
3443 {
3446 }
3447
3455 else
3457 datlocprovider);
3458
3460 {
3463 }
3464 else
3465 {
3467 {
3470 }
3472 {
3475 }
3476 }
3477 if (locale)
3478 {
3481 else
3483
3485 }
3486
3488 {
3491 }
3492
3493 /*
3494 * For binary upgrade, carry over the collation version. For normal
3495 * dump/restore, omit the version, so that it is computed upon restore.
3496 */
3498 {
3500 {
3504 fout);
3505 }
3506 }
3507
3508 /*
3509 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3510 * thing; the decision whether to specify a tablespace should be left till
3511 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3512 * label the DATABASE entry with the tablespace and let the normal
3513 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3514 * attention to default_tablespace, so that won't work.
3515 */
3517 !dopt->outputNoTablespaces)
3521
3523 qdatname);
3524
3526
3531 .owner = dba,
3533 .section = SECTION_PRE_DATA,
3535 .dropStmt = delQry->data));
3536
3537 /* Compute correct tag for archive entry */
3539
3540 /* Dump DB comment if any */
3541 {
3542 /*
3543 * 8.2 and up keep comments on shared objects in a shared table, so we
3544 * cannot use the dumpComment() code used for other database objects.
3545 * Be careful that the ArchiveEntry parameters match that function.
3546 */
3548
3550 {
3552
3553 /*
3554 * Generates warning when loaded into a differently-named
3555 * database.
3556 */
3560
3563 .owner = dba,
3564 .description = "COMMENT",
3565 .section = SECTION_NONE,
3566 .createStmt = dbQry->data,
3567 .deps = &dbDumpId,
3568 .nDeps = 1));
3569 }
3570 }
3571
3572 /* Dump DB security label, if enabled */
3574 {
3577
3579
3587 .owner = dba,
3588 .description = "SECURITY LABEL",
3589 .section = SECTION_NONE,
3590 .createStmt = seclabelQry->data,
3591 .deps = &dbDumpId,
3592 .nDeps = 1));
3595 }
3596
3597 /*
3598 * Dump ACL if any. Note that we do not support initial privileges
3599 * (pg_init_privs) on databases.
3600 */
3601 dbdacl.privtype = 0;
3603
3607
3608 /*
3609 * Now construct a DATABASE PROPERTIES archive entry to restore any
3610 * non-default database-level properties. (The reason this must be
3611 * separate is that we cannot put any additional commands into the TOC
3612 * entry that has CREATE DATABASE. pg_restore would execute such a group
3613 * in an implicit transaction block, and the backend won't allow CREATE
3614 * DATABASE in that context.)
3615 */
3618
3622
3624 {
3626 qdatname);
3627
3628 /*
3629 * The backend won't accept DROP DATABASE on a template database. We
3630 * can deal with that by removing the template marking before the DROP
3631 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3632 * since no such command is currently supported, fake it with a direct
3633 * UPDATE on pg_database.
3634 */
3636 "SET datistemplate = false WHERE datname = ");
3639 }
3640
3641 /*
3642 * We do not restore pg_database.dathasloginevt because it is set
3643 * automatically on login event trigger creation.
3644 */
3645
3646 /* Add database-specific SET options */
3648
3649 /*
3650 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3651 * entry, too, for lack of a better place.
3652 */
3654 {
3657 "SET datfrozenxid = '%u', datminmxid = '%u'\n"
3658 "WHERE datname = ",
3659 frozenxid, minmxid);
3662 }
3663
3667 .owner = dba,
3669 .section = SECTION_PRE_DATA,
3671 .dropStmt = delQry->data,
3672 .deps = &dbDumpId));
3673
3674 /*
3675 * pg_largeobject comes from the old system intact, so set its
3676 * relfrozenxids, relminmxids and relfilenode.
3677 *
3678 * pg_largeobject_metadata also comes from the old system intact for
3679 * upgrades from v16 and newer, so set its relfrozenxids, relminmxids, and
3680 * relfilenode, too. pg_upgrade can't copy/link the files from older
3681 * versions because aclitem (needed by pg_largeobject_metadata.lomacl)
3682 * changed its storage format in v16.
3683 */
3685 {
3693 ii_relfilenode,
3694 ii_oid,
3695 ii_relminmxid;
3696
3699 "FROM pg_catalog.pg_class\n"
3700 "WHERE oid IN (%u, %u, %u, %u);\n",
3703 else
3705 "FROM pg_catalog.pg_class\n"
3706 "WHERE oid IN (%u, %u);\n",
3708
3710
3715
3716 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3717 appendPQExpBufferStr(lomHorizonQry, "\n-- For binary upgrade, set pg_largeobject_metadata relfrozenxid and relminmxid\n");
3718 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3719 appendPQExpBufferStr(lomOutQry, "\n-- For binary upgrade, preserve pg_largeobject_metadata and index relfilenodes\n");
3721 {
3722 Oid oid;
3723 RelFileNumber relfilenumber;
3726
3729
3731 oid == LargeObjectLOidPNIndexId)
3732 {
3735 }
3736 else
3737 {
3740 }
3741
3743 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
3744 "WHERE oid = %u;\n",
3748
3750 oid == LargeObjectMetadataRelationId)
3752 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
3753 relfilenumber);
3755 oid == LargeObjectMetadataOidIndexId)
3757 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
3758 relfilenumber);
3759 }
3760
3762 "TRUNCATE pg_catalog.pg_largeobject;\n");
3764 "TRUNCATE pg_catalog.pg_largeobject_metadata;\n");
3765
3768
3772 .section = SECTION_PRE_DATA,
3773 .createStmt = loOutQry->data));
3774
3779 .section = SECTION_PRE_DATA,
3780 .createStmt = lomOutQry->data));
3781
3783
3789 }
3790
3791 PQclear(res);
3792
3798}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, buildShSecLabelQuery(), comment, conn, createDumpId(), createPQExpBuffer(), nameData::data, datconnlimit, datistemplate, datlocprovider, datname, description, destroyPQExpBuffer(), dumpACL(), dumpDatabaseConfig(), emitShSecLabels(), encoding, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), free, GetConnection(), getRoleName(), i, InvalidDumpId, nilCatalogId, _dumpOptions::no_comments, _dumpOptions::no_security_labels, _dumpOptions::outputNoTablespaces, pg_fatal, pg_log_info, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, resetPQExpBuffer(), SECTION_NONE, SECTION_PRE_DATA, and tablespace.
Referenced by main().
◆ dumpDatabaseConfig()
|
static |
Definition at line 3805 of file pg_dump.c.
3807{
3810 PGresult *res;
3811
3812 /* First collect database-specific options */
3814 "WHERE setrole = 0 AND setdatabase = '%u'::oid",
3815 dboid);
3816
3818
3822 outbuf);
3823
3824 PQclear(res);
3825
3826 /* Now look for role-and-database-specific options */
3828 "FROM pg_db_role_setting s, pg_roles r "
3829 "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
3830 dboid);
3831
3833
3838 outbuf);
3839
3840 PQclear(res);
3841
3843}
References buf, conn, createPQExpBuffer(), dbname, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), GetConnection(), i, makeAlterConfigCommand(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, and printfPQExpBuffer().
Referenced by dumpDatabase().
◆ dumpDefaultACL()
|
static |
Definition at line 16334 of file pg_dump.c.
16335{
16337 PQExpBuffer q;
16338 PQExpBuffer tag;
16340
16341 /* Do nothing if not dumping schema, or if we're skipping ACLs */
16343 return;
16344
16345 q = createPQExpBuffer();
16346 tag = createPQExpBuffer();
16347
16349 {
16352 break;
16355 break;
16358 break;
16361 break;
16364 break;
16367 break;
16368 default:
16369 /* shouldn't get here */
16373 }
16374
16376
16377 /* build the actual command(s) for this tuple */
16381 daclinfo->dacl.acl,
16383 daclinfo->defaclrole,
16384 fout->remoteVersion,
16385 q))
16387 daclinfo->dacl.acl);
16388
16392 .namespace = daclinfo->dobj.namespace ?
16394 .owner = daclinfo->defaclrole,
16396 .section = SECTION_POST_DATA,
16397 .createStmt = q->data));
16398
16399 destroyPQExpBuffer(tag);
16400 destroyPQExpBuffer(q);
16401}
References _dumpOptions::aclsSkip, appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), buildDefaultACLCommands(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, _dumpOptions::dumpSchema, fb(), pg_fatal, SECTION_POST_DATA, and type.
Referenced by dumpDumpableObject().
◆ dumpDomain()
Definition at line 12717 of file pg_dump.c.
12718{
12723 PGresult *res;
12730 Oid typcollation;
12732
12734 {
12735 /* Set up query for domain-specific details */
12736 appendPQExpBufferStr(query,
12737 "PREPARE dumpDomain(pg_catalog.oid) AS\n");
12738
12740 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
12741 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
12742 "t.typdefault, "
12743 "CASE WHEN t.typcollation <> u.typcollation "
12744 "THEN t.typcollation ELSE 0 END AS typcollation "
12745 "FROM pg_catalog.pg_type t "
12746 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
12747 "WHERE t.oid = $1");
12748
12750
12752 }
12753
12754 printfPQExpBuffer(query,
12755 "EXECUTE dumpDomain('%u')",
12756 tyinfo->dobj.catId.oid);
12757
12759
12765 {
12768 }
12769 else
12772
12775 tyinfo->dobj.catId.oid,
12776 true, /* force array type */
12777 false); /* force multirange type */
12778
12781
12782 appendPQExpBuffer(q,
12783 "CREATE DOMAIN %s AS %s",
12784 qualtypname,
12785 typdefn);
12786
12787 /* Print collation only if different from base type's collation */
12789 {
12791
12795 }
12796
12797 /*
12798 * Print a not-null constraint if there's one. In servers older than 17
12799 * these don't have names, so just print it unadorned; in newer ones they
12800 * do, but most of the time it's going to be the standard generated one,
12801 * so omit the name in that case also.
12802 */
12804 {
12807 else
12808 {
12810
12812 {
12814
12815 /* XXX should match ChooseConstraintName better */
12817
12820 else
12824 }
12825 }
12826 }
12827
12829 {
12833 else
12835 }
12836
12837 PQclear(res);
12838
12839 /*
12840 * Add any CHECK constraints for the domain
12841 */
12843 {
12845
12849 }
12850
12852
12854
12858 tyinfo->dobj.namespace->dobj.name);
12859
12863 .namespace = tyinfo->dobj.namespace->dobj.name,
12864 .owner = tyinfo->rolname,
12865 .description = "DOMAIN",
12866 .section = SECTION_PRE_DATA,
12867 .createStmt = q->data,
12868 .dropStmt = delq->data));
12869
12870 /* Dump Domain Comments and Security Labels */
12875
12880
12884 tyinfo->dobj.namespace->dobj.name,
12886
12887 /* Dump any per-constraint comments */
12889 {
12892
12893 /* but only if the constraint itself was dumped here */
12895 continue;
12896
12900
12903 tyinfo->dobj.namespace->dobj.name,
12904 tyinfo->rolname,
12906
12908 }
12909
12910 /*
12911 * And a comment on the not-null constraint, if there's one -- but only if
12912 * the constraint itself was dumped here
12913 */
12915 {
12917
12920
12923 tyinfo->dobj.namespace->dobj.name,
12924 tyinfo->rolname,
12927 }
12928
12929 destroyPQExpBuffer(q);
12931 destroyPQExpBuffer(query);
12934}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), _constraintInfo::condef, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, free, i, InvalidDumpId, _dumpableObject::name, OidIsValid, pg_strdup(), PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPDOMAIN, printfPQExpBuffer(), psprintf(), SECTION_PRE_DATA, and _constraintInfo::separate.
Referenced by dumpType().
◆ dumpDumpableObject()
|
static |
Definition at line 11678 of file pg_dump.c.
11679{
11680 /*
11681 * Clear any dump-request bits for components that don't exist for this
11682 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
11683 * request for every kind of object.)
11684 */
11686
11687 /* Now, short-circuit if there's nothing to be done here. */
11689 return;
11690
11692 {
11695 break;
11698 break;
11701 break;
11704 break;
11707 break;
11710 break;
11713 break;
11716 break;
11719 break;
11722 break;
11725 break;
11728 break;
11731 break;
11734 break;
11737 break;
11740 break;
11743 break;
11747 break;
11750 break;
11753 break;
11756 break;
11759 break;
11762 break;
11765 break;
11768 break;
11771 break;
11774 break;
11777 break;
11780 break;
11782 /* table rowtypes and array types are never dumped separately */
11783 break;
11786 break;
11789 break;
11792 break;
11795 break;
11798 break;
11801 break;
11804 break;
11807 break;
11810 {
11812 TocEntry *te;
11813
11817 dobj->name);
11818
11821 .owner = loinfo->rolname,
11822 .description = "BLOBS",
11823 .section = SECTION_DATA,
11824 .deps = dobj->dependencies,
11825 .nDeps = dobj->nDeps,
11826 .dumpFn = dumpLOs,
11827 .dumpArg = loinfo));
11828
11829 /*
11830 * Set the TocEntry's dataLength in case we are doing a
11831 * parallel dump and want to order dump jobs by table size.
11832 * (We need some size estimate for every TocEntry with a
11833 * DataDumper function.) We don't currently have any cheap
11834 * way to estimate the size of LOs, but fortunately it doesn't
11835 * matter too much as long as we get large batches of LOs
11836 * processed reasonably early. Assume 8K per blob.
11837 */
11839 }
11840 break;
11843 break;
11846 break;
11849 break;
11853 break;
11856 break;
11859 break;
11862 break;
11865 /* never dumped, nothing to do */
11866 break;
11867 }
11868}
References ARCHIVE_OPTS, ArchiveEntry(), _dumpableObject::components, _tocEntry::dataLength, DO_ACCESS_METHOD, DO_AGG, DO_ATTRDEF, DO_CAST, DO_COLLATION, DO_CONSTRAINT, DO_CONVERSION, DO_DEFAULT_ACL, DO_DUMMY_TYPE, DO_EVENT_TRIGGER, DO_EXTENSION, DO_FDW, DO_FK_CONSTRAINT, DO_FOREIGN_SERVER, DO_FUNC, DO_INDEX, DO_INDEX_ATTACH, DO_LARGE_OBJECT, DO_LARGE_OBJECT_DATA, DO_NAMESPACE, DO_OPCLASS, DO_OPERATOR, DO_OPFAMILY, DO_POLICY, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, DO_PROCLANG, DO_PUBLICATION, DO_PUBLICATION_REL, DO_PUBLICATION_TABLE_IN_SCHEMA, DO_REFRESH_MATVIEW, DO_REL_STATS, DO_RULE, DO_SEQUENCE_SET, DO_SHELL_TYPE, DO_STATSEXT, DO_SUBSCRIPTION, DO_SUBSCRIPTION_REL, DO_TABLE, DO_TABLE_ATTACH, DO_TABLE_DATA, DO_TRANSFORM, DO_TRIGGER, DO_TSCONFIG, DO_TSDICT, DO_TSPARSER, DO_TSTEMPLATE, DO_TYPE, _dumpableObject::dump, DUMP_COMPONENT_DATA, dumpAccessMethod(), dumpAgg(), dumpAttrDef(), dumpCast(), dumpCollation(), dumpConstraint(), dumpConversion(), dumpDefaultACL(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpLO(), dumpLOs(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationNamespace(), dumpPublicationTable(), dumpRelationStats(), dumpRule(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStatisticsExtStats(), dumpSubscription(), dumpSubscriptionTable(), dumpTable(), dumpTableAttach(), dumpTableData(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpType(), fb(), findObjectByDumpId(), _dumpableObject::objType, pg_fatal, refreshMatViewData(), _namespaceInfo::rolname, and SECTION_DATA.
Referenced by main().
◆ dumpEncoding()
Definition at line 3849 of file pg_dump.c.
3850{
3853
3855
3859
3863 .section = SECTION_PRE_DATA,
3864 .createStmt = qry->data));
3865
3866 destroyPQExpBuffer(qry);
3867}
References appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, description, destroyPQExpBuffer(), Archive::encoding, fb(), nilCatalogId, pg_encoding_to_char, pg_log_info, and SECTION_PRE_DATA.
Referenced by main().
◆ dumpEnumType()
Definition at line 12106 of file pg_dump.c.
12107{
12112 PGresult *res;
12113 int num,
12114 i;
12115 Oid enum_oid;
12121
12123 {
12124 /* Set up query for enum-specific details */
12125 appendPQExpBufferStr(query,
12126 "PREPARE dumpEnumType(pg_catalog.oid) AS\n"
12127 "SELECT oid, enumlabel "
12128 "FROM pg_catalog.pg_enum "
12129 "WHERE enumtypid = $1 "
12130 "ORDER BY enumsortorder");
12131
12133
12135 }
12136
12137 printfPQExpBuffer(query,
12138 "EXECUTE dumpEnumType('%u')",
12139 tyinfo->dobj.catId.oid);
12140
12142
12143 num = PQntuples(res);
12144
12147
12148 /*
12149 * CASCADE shouldn't be required here as for normal types since the I/O
12150 * functions are generic and do not get dropped.
12151 */
12153
12156 tyinfo->dobj.catId.oid,
12157 false, false);
12158
12160 qualtypname);
12161
12163 {
12165
12166 /* Labels with server-assigned oids */
12168 {
12174 }
12175 }
12176
12178
12180 {
12183
12184 /* Labels with dump-assigned (preserved) oids */
12186 {
12189
12192 appendPQExpBuffer(q,
12193 "SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
12194 enum_oid);
12198 }
12199 }
12200
12204 tyinfo->dobj.namespace->dobj.name);
12205
12209 .namespace = tyinfo->dobj.namespace->dobj.name,
12210 .owner = tyinfo->rolname,
12211 .description = "TYPE",
12212 .section = SECTION_PRE_DATA,
12213 .createStmt = q->data,
12214 .dropStmt = delq->data));
12215
12216 /* Dump Type Comments and Security Labels */
12221
12226
12230 tyinfo->dobj.namespace->dobj.name,
12232
12233 PQclear(res);
12234 destroyPQExpBuffer(q);
12236 destroyPQExpBuffer(query);
12239}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), fmtId(), fmtQualifiedDumpable, free, i, InvalidDumpId, label, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, PREPQUERY_DUMPENUMTYPE, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpType().
◆ dumpEventTrigger()
|
static |
Definition at line 19663 of file pg_dump.c.
19664{
19666 PQExpBuffer query;
19669
19670 /* Do nothing if not dumping schema */
19672 return;
19673
19674 query = createPQExpBuffer();
19676
19678
19683
19685 {
19689 }
19690
19694
19696 {
19698 qevtname);
19700 {
19701 case 'D':
19703 break;
19704 case 'A':
19706 break;
19707 case 'R':
19709 break;
19710 default:
19712 break;
19713 }
19715 }
19716
19718 qevtname);
19719
19723
19727 .owner = evtinfo->evtowner,
19728 .description = "EVENT TRIGGER",
19729 .section = SECTION_POST_DATA,
19730 .createStmt = query->data,
19731 .dropStmt = delqry->data));
19732
19737
19742
19743 destroyPQExpBuffer(query);
19746}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpComment(), _dumpOptions::dumpSchema, dumpSecLabel(), fb(), fmtId(), free, pg_strdup(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpExtension()
|
static |
Definition at line 11952 of file pg_dump.c.
11953{
11955 PQExpBuffer q;
11958
11959 /* Do nothing if not dumping schema */
11961 return;
11962
11963 q = createPQExpBuffer();
11965
11967
11969
11971 {
11972 /*
11973 * In a regular dump, we simply create the extension, intentionally
11974 * not specifying a version, so that the destination installation's
11975 * default version is used.
11976 *
11977 * Use of IF NOT EXISTS here is unlike our behavior for other object
11978 * types; but there are various scenarios in which it's convenient to
11979 * manually create the desired extension before restoring, so we
11980 * prefer to allow it to exist already.
11981 */
11984 }
11985 else
11986 {
11987 /*
11988 * In binary-upgrade mode, it's critical to reproduce the state of the
11989 * database exactly, so our procedure is to create an empty extension,
11990 * restore all the contained objects normally, and add them to the
11991 * extension one by one. This function performs just the first of
11992 * those steps. binary_upgrade_extension_member() takes care of
11993 * adding member objects as they're created.
11994 */
11996 int n;
11997
11998 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
11999
12000 /*
12001 * We unconditionally create the extension, so we must drop it if it
12002 * exists. This could happen if the user deleted 'plpgsql' and then
12003 * readded it, causing its oid to be greater than g_last_builtin_oid.
12004 */
12006
12007 appendPQExpBufferStr(q,
12008 "SELECT pg_catalog.binary_upgrade_create_empty_extension(");
12016
12017 /*
12018 * Note that we're pushing extconfig (an OID array) back into
12019 * pg_extension exactly as-is. This is OK because pg_class OIDs are
12020 * preserved in binary upgrade.
12021 */
12024 else
12029 else
12033 n = 0;
12035 {
12037
12040 {
12041 if (n++ > 0)
12044 }
12045 }
12048 }
12049
12053 .description = "EXTENSION",
12054 .section = SECTION_PRE_DATA,
12055 .createStmt = q->data,
12056 .dropStmt = delq->data));
12057
12058 /* Dump Extension Comments */
12063
12065
12066 destroyPQExpBuffer(q);
12068}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_EXTENSION, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), findObjectByDumpId(), fmtId(), free, i, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpForeignDataWrapper()
Definition at line 16070 of file pg_dump.c.
16071{
16073 PQExpBuffer q;
16076
16077 /* Do nothing if not dumping schema */
16079 return;
16080
16081 q = createPQExpBuffer();
16083
16085
16087 qfdwname);
16088
16091
16094
16097
16099
16101 qfdwname);
16102
16106 NULL);
16107
16111 .owner = fdwinfo->rolname,
16112 .description = "FOREIGN DATA WRAPPER",
16113 .section = SECTION_PRE_DATA,
16114 .createStmt = q->data,
16115 .dropStmt = delq->data));
16116
16117 /* Dump Foreign Data Wrapper Comments */
16122
16123 /* Handle the ACL */
16128
16130
16131 destroyPQExpBuffer(q);
16133}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpACL(), dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), free, InvalidDumpId, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpForeignServer()
|
static |
Definition at line 16140 of file pg_dump.c.
16141{
16143 PQExpBuffer q;
16145 PQExpBuffer query;
16146 PGresult *res;
16148 char *fdwname;
16149
16150 /* Do nothing if not dumping schema */
16152 return;
16153
16154 q = createPQExpBuffer();
16156 query = createPQExpBuffer();
16157
16159
16160 /* look up the foreign-data wrapper */
16162 "FROM pg_foreign_data_wrapper w "
16163 "WHERE w.oid = '%u'",
16164 srvinfo->srvfdw);
16166 fdwname = PQgetvalue(res, 0, 0);
16167
16170 {
16173 }
16175 {
16178 }
16179
16182
16185
16187
16189 qsrvname);
16190
16194
16198 .owner = srvinfo->rolname,
16199 .description = "SERVER",
16200 .section = SECTION_PRE_DATA,
16201 .createStmt = q->data,
16202 .dropStmt = delq->data));
16203
16204 /* Dump Foreign Server Comments */
16209
16210 /* Handle the ACL */
16215
16216 /* Dump user mappings */
16220 srvinfo->rolname,
16222
16223 PQclear(res);
16224
16226
16227 destroyPQExpBuffer(q);
16229 destroyPQExpBuffer(query);
16230}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_USERMAP, dumpACL(), dumpComment(), _dumpOptions::dumpSchema, dumpUserMappings(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), free, InvalidDumpId, pg_strdup(), PQclear, PQgetvalue, and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpFunc()
Definition at line 13467 of file pg_dump.c.
13468{
13470 PQExpBuffer query;
13471 PQExpBuffer q;
13474 PGresult *res;
13480 char *prosrc;
13487 char *prokind;
13500 const char *keyword;
13501
13502 /* Do nothing if not dumping schema */
13504 return;
13505
13506 query = createPQExpBuffer();
13507 q = createPQExpBuffer();
13510
13512 {
13513 /* Set up query for function-specific details */
13514 appendPQExpBufferStr(query,
13515 "PREPARE dumpFunc(pg_catalog.oid) AS\n");
13516
13517 appendPQExpBufferStr(query,
13518 "SELECT\n"
13519 "proretset,\n"
13520 "prosrc,\n"
13521 "probin,\n"
13522 "provolatile,\n"
13523 "proisstrict,\n"
13524 "prosecdef,\n"
13525 "lanname,\n"
13526 "proconfig,\n"
13527 "procost,\n"
13528 "prorows,\n"
13529 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
13530 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n"
13531 "pg_catalog.pg_get_function_result(p.oid) AS funcresult,\n"
13532 "proleakproof,\n");
13533
13535 appendPQExpBufferStr(query,
13536 "array_to_string(protrftypes, ' ') AS protrftypes,\n");
13537 else
13538 appendPQExpBufferStr(query,
13539 "NULL AS protrftypes,\n");
13540
13542 appendPQExpBufferStr(query,
13543 "proparallel,\n");
13544 else
13545 appendPQExpBufferStr(query,
13546 "'u' AS proparallel,\n");
13547
13549 appendPQExpBufferStr(query,
13550 "prokind,\n");
13551 else
13552 appendPQExpBufferStr(query,
13553 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind,\n");
13554
13556 appendPQExpBufferStr(query,
13557 "prosupport,\n");
13558 else
13559 appendPQExpBufferStr(query,
13560 "'-' AS prosupport,\n");
13561
13563 appendPQExpBufferStr(query,
13564 "pg_get_function_sqlbody(p.oid) AS prosqlbody\n");
13565 else
13566 appendPQExpBufferStr(query,
13567 "NULL AS prosqlbody\n");
13568
13569 appendPQExpBufferStr(query,
13570 "FROM pg_catalog.pg_proc p, pg_catalog.pg_language l\n"
13571 "WHERE p.oid = $1 "
13572 "AND l.oid = p.prolang");
13573
13575
13577 }
13578
13579 printfPQExpBuffer(query,
13580 "EXECUTE dumpFunc('%u')",
13582
13584
13587 {
13591 }
13592 else
13593 {
13594 prosrc = NULL;
13597 }
13613
13614 /*
13615 * See backend/commands/functioncmds.c for details of how the 'AS' clause
13616 * is used.
13617 */
13619 {
13621 }
13623 {
13626 if (prosrc[0] != '\0')
13627 {
13629
13630 /*
13631 * where we have bin, use dollar quoting if allowed and src
13632 * contains quote or backslash; else use regular quoting.
13633 */
13637 else
13639 }
13640 }
13641 else
13642 {
13644 /* with no bin, dollar quote src unconditionally if allowed */
13647 else
13649 }
13650
13652 {
13655 }
13656 else
13657 {
13659 nconfigitems = 0;
13660 }
13661
13664
13666
13669 funcsig);
13670
13672 keyword = "PROCEDURE";
13673 else
13674 keyword = "FUNCTION"; /* works for window functions too */
13675
13677 keyword, qual_funcsig);
13678
13680 keyword,
13683 funcsig);
13684
13686 /* no result type to output */ ;
13689 else
13693 zeroIsError));
13694
13696
13698 {
13701
13705 {
13710 }
13711
13713 }
13714
13717
13719 {
13727 }
13728
13731
13734
13737
13738 /*
13739 * COST and ROWS are emitted only if present and not default, so as not to
13740 * break backwards-compatibility of the dump without need. Keep this code
13741 * in sync with the defaults in functioncmds.c.
13742 */
13744 {
13746 {
13747 /* default cost is 1 */
13750 }
13751 else
13752 {
13753 /* default cost is 100 */
13756 }
13757 }
13761
13763 {
13764 /* We rely on regprocout to provide quoting and qualification */
13766 }
13767
13769 {
13777 }
13778
13780 {
13781 /* we feel free to scribble on configitems[] here */
13783 char *pos;
13784
13787 continue;
13788 *pos++ = '\0';
13790
13791 /*
13792 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
13793 * by flatten_set_variable_args() before they were put into the
13794 * proconfig array. However, because the quoting rules used there
13795 * aren't exactly like SQL's, we have to break the list value apart
13796 * and then quote the elements as string literals. (The elements may
13797 * be double-quoted as-is, but we can't just feed them to the SQL
13798 * parser; it would do the wrong thing with elements that are
13799 * zero-length or longer than NAMEDATALEN.) Also, we need a special
13800 * case for empty lists.
13801 *
13802 * Variables that are not so marked should just be emitted as simple
13803 * string literals. If the variable is not known to
13804 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
13805 * to use GUC_LIST_QUOTE for extension variables.
13806 */
13808 {
13811
13812 /* Parse string into list of identifiers */
13813 /* this shouldn't fail really */
13815 {
13816 /* Special case: represent an empty list as NULL */
13820 {
13824 }
13825 }
13827 }
13828 else
13830 }
13831
13833
13835 "pg_catalog.pg_proc", keyword,
13836 qual_funcsig);
13837
13840 keyword, funcsig,
13842
13847 .owner = finfo->rolname,
13848 .description = keyword,
13849 .section = finfo->postponed_def ?
13851 .createStmt = q->data,
13853
13854 /* Dump Function Comments and Security Labels */
13859
13864
13870
13871 PQclear(res);
13872
13873 destroyPQExpBuffer(query);
13874 destroyPQExpBuffer(q);
13882}
References append_depends_on_extension(), appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, appendStringLiteralDQ(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), _funcInfo::dacl, PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::disable_dollar_quoting, _funcInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), _dumpableObject::dumpId, _dumpOptions::dumpSchema, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtId(), format_function_arguments(), format_function_signature(), free, FUNC_MAX_ARGS, getFormattedTypeName(), i, InvalidDumpId, _dumpableObject::name, CatalogId::oid, parseOidArray(), parsePGArray(), pg_fatal, pg_free(), pg_malloc(), _funcInfo::postponed_def, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPFUNC, printfPQExpBuffer(), _funcInfo::prorettype, psprintf(), _funcInfo::rolname, SECTION_POST_DATA, SECTION_PRE_DATA, SplitGUCList(), variable_is_guc_list_quote(), zeroAsNone, and zeroIsError.
Referenced by dumpDumpableObject().
◆ dumpIndex()
Definition at line 18283 of file pg_dump.c.
18284{
18288 PQExpBuffer q;
18292
18293 /* Do nothing if not dumping schema */
18295 return;
18296
18297 q = createPQExpBuffer();
18299
18302
18303 /*
18304 * If there's an associated constraint, don't dump the index per se, but
18305 * do dump any comment for it. (This is safe because dependency ordering
18306 * will have ensured the constraint is emitted first.) Note that the
18307 * emitted comment has to be shown as depending on the constraint, not the
18308 * index, in such cases.
18309 */
18311 {
18318
18321 indxinfo->dobj.catId.oid);
18322
18323 /* Plain secondary index */
18325
18326 /*
18327 * Append ALTER TABLE commands as needed to set properties that we
18328 * only have ALTER TABLE syntax for. Keep this in sync with the
18329 * similar code in dumpConstraint!
18330 */
18331
18332 /* If the index is clustered, we need to record that. */
18334 {
18337 /* index name is not qualified in this syntax */
18339 qindxname);
18340 }
18341
18342 /*
18343 * If the index has any statistics on some of its columns, generate
18344 * the associated ALTER INDEX queries.
18345 */
18347 {
18349
18356
18358 {
18360
18361 /*
18362 * Note that this is a column number, so no quotes should be
18363 * used.
18364 */
18369 }
18370 }
18371
18372 /* Indexes can depend on extensions */
18374 "pg_catalog.pg_class",
18376
18377 /* If the index defines identity, we need to record that. */
18379 {
18382 /* index name is not qualified in this syntax */
18384 qindxname);
18385 }
18386
18387 /*
18388 * If this index is a member of a partitioned index, the backend will
18389 * not allow us to drop it separately, so don't try. It will go away
18390 * automatically when we drop either the index's table or the
18391 * partitioned index. (If, in a selective restore with --clean, we
18392 * drop neither of those, then this index will not be dropped either.
18393 * But that's fine, and even if you think it's not, the backend won't
18394 * let us do differently.)
18395 */
18398
18402 .namespace = tbinfo->dobj.namespace->dobj.name,
18403 .tablespace = indxinfo->tablespace,
18404 .owner = tbinfo->rolname,
18405 .description = "INDEX",
18406 .section = SECTION_POST_DATA,
18407 .createStmt = q->data,
18408 .dropStmt = delq->data));
18409
18412 }
18413
18414 /* Dump Index Comments */
18417 tbinfo->dobj.namespace->dobj.name,
18418 tbinfo->rolname,
18419 indxinfo->dobj.catId, 0,
18421 indxinfo->dobj.dumpId);
18422
18423 destroyPQExpBuffer(q);
18427}
References append_depends_on_extension(), appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_set_pg_class_oids(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, j, parsePGArray(), pg_fatal, pg_strdup(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpIndexAttach()
|
static |
Definition at line 18434 of file pg_dump.c.
18435{
18436 /* Do nothing if not dumping schema */
18438 return;
18439
18441 {
18443
18448
18449 /*
18450 * There is no need for a dropStmt since the drop is done implicitly
18451 * when we drop either the index's table or the partitioned index.
18452 * Moreover, since there's no ALTER INDEX DETACH PARTITION command,
18453 * there's no way to do it anyway. (If you think to change this,
18454 * consider also what to do with --if-exists.)
18455 *
18456 * Although this object doesn't really have ownership as such, set the
18457 * owner field anyway to ensure that the command is run by the correct
18458 * role at restore time.
18459 */
18462 .namespace = attachinfo->dobj.namespace->dobj.name,
18463 .owner = attachinfo->parentIdx->indextable->rolname,
18464 .description = "INDEX ATTACH",
18465 .section = SECTION_POST_DATA,
18466 .createStmt = q->data));
18467
18468 destroyPQExpBuffer(q);
18469 }
18470}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, fb(), fmtQualifiedDumpable, and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpLO()
Definition at line 4125 of file pg_dump.c.
4126{
4128
4129 /*
4130 * The "definition" is just a newline-separated list of OIDs. We need to
4131 * put something into the dropStmt too, but it can just be a comment.
4132 */
4135
4139 .owner = loinfo->rolname,
4140 .description = "BLOB METADATA",
4141 .section = SECTION_DATA,
4142 .createStmt = cquery->data,
4143 .dropStmt = "-- dummy"));
4144
4145 /*
4146 * Dump per-blob comments and seclabels if any. We assume these are rare
4147 * enough that it's okay to generate retail TOC entries for them.
4148 */
4150 DUMP_COMPONENT_SECLABEL))
4151 {
4153 {
4154 CatalogId catId;
4156
4157 /* Build identifying info for this blob */
4161
4165 catId, 0, loinfo->dobj.dumpId);
4166
4170 catId, 0, loinfo->dobj.dumpId);
4171 }
4172 }
4173
4174 /*
4175 * Dump the ACLs if any (remember that all blobs in the group will have
4176 * the same ACL). If there's just one blob, dump a simple ACL entry; if
4177 * there's more, make a "LARGE OBJECTS" entry that really contains only
4178 * the ACL for the first blob. _printTocEntry() will be cued by the tag
4179 * string to emit a mutated version for each blob.
4180 */
4182 {
4184
4185 /* Build identifying info for the first blob */
4187
4189 {
4191
4194
4198 }
4199 else
4200 {
4204 }
4205 }
4206
4208}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), fb(), i, InvalidDumpId, CatalogId::oid, SECTION_DATA, snprintf, and CatalogId::tableoid.
Referenced by dumpDumpableObject().
◆ dumpLOs()
Definition at line 4215 of file pg_dump.c.
4216{
4220
4222
4224 {
4226 int loFd;
4227 int cnt;
4228
4229 /* Open the LO */
4231 if (loFd == -1)
4234
4236
4237 /* Now read it in chunks, sending data to archive */
4238 do
4239 {
4241 if (cnt < 0)
4244
4246 } while (cnt > 0);
4247
4249
4251 }
4252
4253 return 1;
4254}
References arg, buf, conn, EndLO(), fb(), GetConnection(), i, INV_READ, lo_close(), lo_open(), lo_read(), LOBBUFSIZE, pg_fatal, pg_log_info, PQerrorMessage(), StartLO(), and WriteData().
Referenced by dumpDumpableObject().
◆ dumpNamespace()
|
static |
Definition at line 11875 of file pg_dump.c.
11876{
11878 PQExpBuffer q;
11881
11882 /* Do nothing if not dumping schema */
11884 return;
11885
11886 q = createPQExpBuffer();
11888
11890
11892 {
11895 }
11896 else
11897 {
11898 /* see selectDumpableNamespace() */
11900 "-- *not* dropping schema, since initdb creates it\n");
11901 appendPQExpBufferStr(q,
11902 "-- *not* creating schema, since initdb creates it\n");
11903 }
11904
11908
11912 .owner = nspinfo->rolname,
11913 .description = "SCHEMA",
11914 .section = SECTION_PRE_DATA,
11915 .createStmt = q->data,
11916 .dropStmt = delq->data));
11917
11918 /* Dump Schema Comments and Security Labels */
11920 {
11922
11928 initdb_comment);
11929 }
11930
11935
11940
11942
11943 destroyPQExpBuffer(q);
11945}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpCommentExtended(), _dumpOptions::dumpSchema, dumpSecLabel(), fb(), fmtId(), free, InvalidDumpId, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpOpclass()
|
static |
Definition at line 14503 of file pg_dump.c.
14504{
14506 PQExpBuffer query;
14507 PQExpBuffer q;
14510 PGresult *res;
14511 int ntups;
14527 char *opcintype;
14530 char *opcfamily;
14533 char *amname;
14536 char *sortfamily;
14544
14545 /* Do nothing if not dumping schema */
14547 return;
14548
14549 query = createPQExpBuffer();
14550 q = createPQExpBuffer();
14553
14554 /* Get additional fields from the pg_opclass row */
14556 "opckeytype::pg_catalog.regtype, "
14557 "opcdefault, opcfamily, "
14558 "opfname AS opcfamilyname, "
14559 "nspname AS opcfamilynsp, "
14560 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
14561 "FROM pg_catalog.pg_opclass c "
14562 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
14563 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14564 "WHERE c.oid = '%u'::pg_catalog.oid",
14565 opcinfo->dobj.catId.oid);
14566
14568
14576
14577 /* opcintype may still be needed after we PQclear res */
14581 /* opcfamily will still be needed after we PQclear res */
14585 /* amname will still be needed after we PQclear res */
14587
14591 fmtId(amname));
14592
14593 /* Build the fixed portion of the CREATE command */
14599 opcintype,
14600 fmtId(amname));
14602 {
14606 }
14608
14610
14612 {
14614 opckeytype);
14616 }
14617
14618 PQclear(res);
14619
14620 /*
14621 * Now fetch and print the OPERATOR entries (pg_amop rows).
14622 *
14623 * Print only those opfamily members that are tied to the opclass by
14624 * pg_depend entries.
14625 */
14626 resetPQExpBuffer(query);
14628 "amopopr::pg_catalog.regoperator, "
14629 "opfname AS sortfamily, "
14630 "nspname AS sortfamilynsp "
14631 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14632 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14633 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14634 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14635 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14636 "AND refobjid = '%u'::pg_catalog.oid "
14637 "AND amopfamily = '%s'::pg_catalog.oid "
14638 "ORDER BY amopstrategy",
14639 opcinfo->dobj.catId.oid,
14640 opcfamily);
14641
14643
14644 ntups = PQntuples(res);
14645
14650
14652 {
14657
14660
14663
14665 {
14669 }
14670
14672 }
14673
14674 PQclear(res);
14675
14676 /*
14677 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14678 *
14679 * Print only those opfamily members that are tied to the opclass by
14680 * pg_depend entries.
14681 *
14682 * We print the amproclefttype/amprocrighttype even though in most cases
14683 * the backend could deduce the right values, because of the corner case
14684 * of a btree sort support function for a cross-type comparison.
14685 */
14686 resetPQExpBuffer(query);
14687
14689 "amproc::pg_catalog.regprocedure, "
14690 "amproclefttype::pg_catalog.regtype, "
14691 "amprocrighttype::pg_catalog.regtype "
14692 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14693 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14694 "AND refobjid = '%u'::pg_catalog.oid "
14695 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14696 "AND objid = ap.oid "
14697 "ORDER BY amprocnum",
14698 opcinfo->dobj.catId.oid);
14699
14701
14702 ntups = PQntuples(res);
14703
14708
14710 {
14715
14718
14720
14723
14725
14727 }
14728
14729 PQclear(res);
14730
14731 /*
14732 * If needComma is still false it means we haven't added anything after
14733 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
14734 * clause with the same datatype. This isn't sanctioned by the
14735 * documentation, but actually DefineOpClass will treat it as a no-op.
14736 */
14739
14741
14744 fmtId(amname));
14745
14749 opcinfo->dobj.namespace->dobj.name);
14750
14754 .namespace = opcinfo->dobj.namespace->dobj.name,
14755 .owner = opcinfo->rolname,
14756 .description = "OPERATOR CLASS",
14757 .section = SECTION_PRE_DATA,
14758 .createStmt = q->data,
14759 .dropStmt = delq->data));
14760
14761 /* Dump Operator Class Comments */
14766
14767 free(opcintype);
14768 free(opcfamily);
14769 free(amname);
14770 destroyPQExpBuffer(query);
14771 destroyPQExpBuffer(q);
14774}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, i, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, resetPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpOpfamily()
|
static |
Definition at line 14784 of file pg_dump.c.
14785{
14787 PQExpBuffer query;
14788 PQExpBuffer q;
14791 PGresult *res;
14794 int ntups;
14804 char *amname;
14807 char *sortfamily;
14815
14816 /* Do nothing if not dumping schema */
14818 return;
14819
14820 query = createPQExpBuffer();
14821 q = createPQExpBuffer();
14824
14825 /*
14826 * Fetch only those opfamily members that are tied directly to the
14827 * opfamily by pg_depend entries.
14828 */
14830 "amopopr::pg_catalog.regoperator, "
14831 "opfname AS sortfamily, "
14832 "nspname AS sortfamilynsp "
14833 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14834 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14835 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14836 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14837 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14838 "AND refobjid = '%u'::pg_catalog.oid "
14839 "AND amopfamily = '%u'::pg_catalog.oid "
14840 "ORDER BY amopstrategy",
14841 opfinfo->dobj.catId.oid,
14842 opfinfo->dobj.catId.oid);
14843
14845
14846 resetPQExpBuffer(query);
14847
14849 "amproc::pg_catalog.regprocedure, "
14850 "amproclefttype::pg_catalog.regtype, "
14851 "amprocrighttype::pg_catalog.regtype "
14852 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14853 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14854 "AND refobjid = '%u'::pg_catalog.oid "
14855 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14856 "AND objid = ap.oid "
14857 "ORDER BY amprocnum",
14858 opfinfo->dobj.catId.oid);
14859
14861
14862 /* Get additional fields from the pg_opfamily row */
14863 resetPQExpBuffer(query);
14864
14866 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
14867 "FROM pg_catalog.pg_opfamily "
14868 "WHERE oid = '%u'::pg_catalog.oid",
14869 opfinfo->dobj.catId.oid);
14870
14872
14874
14875 /* amname will still be needed after we PQclear res */
14877
14881 fmtId(amname));
14882
14883 /* Build the fixed portion of the CREATE command */
14887 fmtId(amname));
14888
14889 PQclear(res);
14890
14891 /* Do we need an ALTER to add loose members? */
14893 {
14897 fmtId(amname));
14898
14900
14901 /*
14902 * Now fetch and print the OPERATOR entries (pg_amop rows).
14903 */
14905
14910
14912 {
14917
14920
14923
14925 {
14929 }
14930
14932 }
14933
14934 /*
14935 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14936 */
14938
14943
14945 {
14950
14953
14956 amproc);
14957
14959 }
14960
14962 }
14963
14966 fmtId(amname));
14967
14971 opfinfo->dobj.namespace->dobj.name);
14972
14976 .namespace = opfinfo->dobj.namespace->dobj.name,
14977 .owner = opfinfo->rolname,
14978 .description = "OPERATOR FAMILY",
14979 .section = SECTION_PRE_DATA,
14980 .createStmt = q->data,
14981 .dropStmt = delq->data));
14982
14983 /* Dump Operator Family Comments */
14988
14989 free(amname);
14992 destroyPQExpBuffer(query);
14993 destroyPQExpBuffer(q);
14996}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, i, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, resetPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpOpr()
Definition at line 14123 of file pg_dump.c.
14124{
14126 PQExpBuffer query;
14127 PQExpBuffer q;
14130 PQExpBuffer details;
14131 PGresult *res;
14142 char *oprkind;
14143 char *oprcode;
14144 char *oprleft;
14145 char *oprright;
14154
14155 /* Do nothing if not dumping schema */
14157 return;
14158
14159 /*
14160 * some operators are invalid because they were the result of user
14161 * defining operators before commutators exist
14162 */
14164 return;
14165
14166 query = createPQExpBuffer();
14167 q = createPQExpBuffer();
14170 details = createPQExpBuffer();
14171
14173 {
14174 /* Set up query for operator-specific details */
14175 appendPQExpBufferStr(query,
14176 "PREPARE dumpOpr(pg_catalog.oid) AS\n"
14177 "SELECT oprkind, "
14178 "oprcode::pg_catalog.regprocedure, "
14179 "oprleft::pg_catalog.regtype, "
14180 "oprright::pg_catalog.regtype, "
14181 "oprcom, "
14182 "oprnegate, "
14183 "oprrest::pg_catalog.regprocedure, "
14184 "oprjoin::pg_catalog.regprocedure, "
14185 "oprcanmerge, oprcanhash "
14186 "FROM pg_catalog.pg_operator "
14187 "WHERE oid = $1");
14188
14190
14192 }
14193
14194 printfPQExpBuffer(query,
14195 "EXECUTE dumpOpr('%u')",
14196 oprinfo->dobj.catId.oid);
14197
14199
14210
14221
14222 /* In PG14 upwards postfix operator support does not exist anymore. */
14225 oprcode);
14226
14229 {
14232 }
14233
14235 oprinfo->dobj.name);
14236
14237 /*
14238 * right unary means there's a left arg and left unary means there's a
14239 * right arg. (Although the "r" case is dead code for PG14 and later,
14240 * continue to support it in case we're dumping from an old server.)
14241 */
14244 {
14247 }
14248 else
14250
14253 {
14256 }
14257 else
14259
14262 {
14265 }
14266
14269 {
14272 }
14273
14276
14279
14282 {
14285 }
14286
14289 {
14292 }
14293
14296 oprid->data);
14297
14301
14305 oprinfo->dobj.namespace->dobj.name);
14306
14310 .namespace = oprinfo->dobj.namespace->dobj.name,
14311 .owner = oprinfo->rolname,
14312 .description = "OPERATOR",
14313 .section = SECTION_PRE_DATA,
14314 .createStmt = q->data,
14315 .dropStmt = delq->data));
14316
14317 /* Dump Operator Comments */
14322
14323 PQclear(res);
14324
14325 destroyPQExpBuffer(query);
14326 destroyPQExpBuffer(q);
14329 destroyPQExpBuffer(details);
14330}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), convertRegProcReference(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtId(), free, getFormattedOperatorName(), OidIsValid, oprid(), pg_log_warning, PQclear, PQfnumber(), PQgetvalue, PREPQUERY_DUMPOPR, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpPolicy()
|
static |
Definition at line 4433 of file pg_dump.c.
4434{
4437 PQExpBuffer query;
4441 const char *cmd;
4442 char *tag;
4443
4444 /* Do nothing if not dumping schema */
4446 return;
4447
4448 /*
4449 * If polname is NULL, then this record is just indicating that ROW LEVEL
4450 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
4451 * ROW LEVEL SECURITY.
4452 */
4454 {
4455 query = createPQExpBuffer();
4456
4459
4460 /*
4461 * We must emit the ROW SECURITY object's dependency on its table
4462 * explicitly, because it will not match anything in pg_depend (unlike
4463 * the case for other PolicyInfo objects).
4464 */
4468 .namespace = polinfo->dobj.namespace->dobj.name,
4469 .owner = tbinfo->rolname,
4470 .description = "ROW SECURITY",
4471 .section = SECTION_POST_DATA,
4472 .createStmt = query->data,
4473 .deps = &(tbinfo->dobj.dumpId),
4474 .nDeps = 1));
4475
4476 destroyPQExpBuffer(query);
4477 return;
4478 }
4479
4481 cmd = "";
4483 cmd = " FOR SELECT";
4485 cmd = " FOR INSERT";
4487 cmd = " FOR UPDATE";
4489 cmd = " FOR DELETE";
4490 else
4492 polinfo->polcmd);
4493
4494 query = createPQExpBuffer();
4497
4499
4501
4504
4507
4510
4513
4515
4518
4521
4523
4526 ARCHIVE_OPTS(.tag = tag,
4528 .owner = tbinfo->rolname,
4529 .description = "POLICY",
4530 .section = SECTION_POST_DATA,
4531 .createStmt = query->data,
4532 .dropStmt = delqry->data));
4533
4538
4539 free(tag);
4540 destroyPQExpBuffer(query);
4544}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, pg_fatal, pg_strdup(), psprintf(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpProcLang()
|
static |
Definition at line 13283 of file pg_dump.c.
13284{
13293
13294 /* Do nothing if not dumping schema */
13296 return;
13297
13298 /*
13299 * Try to find the support function(s). It is not an error if we don't
13300 * find them --- if the functions are in the pg_catalog schema, as is
13301 * standard in 8.1 and up, then we won't have loaded them. (In this case
13302 * we will emit a parameterless CREATE LANGUAGE command, which will
13303 * require PL template knowledge in the backend to reload.)
13304 */
13305
13309
13311 {
13315 }
13316
13318 {
13322 }
13323
13324 /*
13325 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
13326 * parameters. Otherwise, we'll write a parameterless command, which will
13327 * be interpreted as CREATE EXTENSION.
13328 */
13332
13335
13337
13339 qlanname);
13340
13342 {
13345 qlanname);
13354 }
13355 else
13356 {
13357 /*
13358 * If not dumping parameters, then use CREATE OR REPLACE so that the
13359 * command will not fail if the language is preinstalled in the target
13360 * database.
13361 *
13362 * Modern servers will interpret this as CREATE EXTENSION IF NOT
13363 * EXISTS; perhaps we should emit that instead? But it might just add
13364 * confusion.
13365 */
13367 qlanname);
13368 }
13370
13374
13378 .owner = plang->lanowner,
13379 .description = "PROCEDURAL LANGUAGE",
13380 .section = SECTION_PRE_DATA,
13381 .createStmt = defqry->data,
13382 .dropStmt = delqry->data,
13383 ));
13384
13385 /* Dump Proc Lang Comments and Security Labels */
13390
13395
13400
13402
13405}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), _dumpOptions::dumpSchema, dumpSecLabel(), fb(), findFuncByOid(), fmtId(), fmtQualifiedDumpable, free, InvalidDumpId, OidIsValid, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpPublication()
|
static |
Definition at line 4667 of file pg_dump.c.
4668{
4671 PQExpBuffer query;
4673 bool first = true;
4674
4675 /* Do nothing if not dumping schema */
4677 return;
4678
4680 query = createPQExpBuffer();
4681
4683
4685 qpubname);
4686
4688 qpubname);
4689
4696
4699 {
4701 first = false;
4702 }
4703
4705 {
4706 if (!first)
4708
4710 first = false;
4711 }
4712
4714 {
4715 if (!first)
4717
4719 first = false;
4720 }
4721
4723 {
4724 if (!first)
4726
4728 first = false;
4729 }
4730
4732
4735
4738
4740
4744 .owner = pubinfo->rolname,
4745 .description = "PUBLICATION",
4746 .section = SECTION_POST_DATA,
4747 .createStmt = query->data,
4748 .dropStmt = delq->data));
4749
4754
4759
4761 destroyPQExpBuffer(query);
4763}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpComment(), _dumpOptions::dumpSchema, dumpSecLabel(), fb(), fmtId(), free, pg_strdup(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpPublicationNamespace()
|
static |
Definition at line 4977 of file pg_dump.c.
4978{
4982 PQExpBuffer query;
4983 char *tag;
4984
4985 /* Do nothing if not dumping schema */
4987 return;
4988
4990
4991 query = createPQExpBuffer();
4992
4995
4996 /*
4997 * There is no point in creating drop query as the drop is done by schema
4998 * drop.
4999 */
5002 ARCHIVE_OPTS(.tag = tag,
5004 .owner = pubinfo->rolname,
5005 .description = "PUBLICATION TABLES IN SCHEMA",
5006 .section = SECTION_POST_DATA,
5007 .createStmt = query->data));
5008
5009 /* These objects can't currently have comments or seclabels */
5010
5011 free(tag);
5012 destroyPQExpBuffer(query);
5013}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), fmtId(), free, psprintf(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpPublicationTable()
|
static |
Definition at line 5020 of file pg_dump.c.
5021{
5025 PQExpBuffer query;
5026 char *tag;
5027
5028 /* Do nothing if not dumping schema */
5030 return;
5031
5033
5034 query = createPQExpBuffer();
5035
5040
5043
5045 {
5046 /*
5047 * It's necessary to add parentheses around the expression because
5048 * pg_get_expr won't supply the parentheses for things like WHERE
5049 * TRUE.
5050 */
5052 }
5054
5055 /*
5056 * There is no point in creating a drop query as the drop is done by table
5057 * drop. (If you think to change this, see also _printTocEntry().)
5058 * Although this object doesn't really have ownership as such, set the
5059 * owner field anyway to ensure that the command is run by the correct
5060 * role at restore time.
5061 */
5064 ARCHIVE_OPTS(.tag = tag,
5066 .owner = pubinfo->rolname,
5067 .description = "PUBLICATION TABLE",
5068 .section = SECTION_POST_DATA,
5069 .createStmt = query->data));
5070
5071 /* These objects can't currently have comments or seclabels */
5072
5073 free(tag);
5074 destroyPQExpBuffer(query);
5075}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, psprintf(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpRangeType()
Definition at line 12246 of file pg_dump.c.
12247{
12252 PGresult *res;
12256 char *procname;
12257
12259 {
12260 /* Set up query for range-specific details */
12261 appendPQExpBufferStr(query,
12262 "PREPARE dumpRangeType(pg_catalog.oid) AS\n");
12263
12264 appendPQExpBufferStr(query,
12265 "SELECT ");
12266
12268 appendPQExpBufferStr(query,
12269 "pg_catalog.format_type(rngmultitypid, NULL) AS rngmultitype, ");
12270 else
12271 appendPQExpBufferStr(query,
12272 "NULL AS rngmultitype, ");
12273
12274 appendPQExpBufferStr(query,
12275 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
12276 "opc.opcname AS opcname, "
12277 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
12278 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
12279 "opc.opcdefault, "
12280 "CASE WHEN rngcollation = st.typcollation THEN 0 "
12281 " ELSE rngcollation END AS collation, "
12282 "rngcanonical, rngsubdiff "
12283 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
12284 " pg_catalog.pg_opclass opc "
12285 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
12286 "rngtypid = $1");
12287
12289
12291 }
12292
12293 printfPQExpBuffer(query,
12294 "EXECUTE dumpRangeType('%u')",
12295 tyinfo->dobj.catId.oid);
12296
12298
12301
12302 /*
12303 * CASCADE shouldn't be required here as for normal types since the I/O
12304 * functions are generic and do not get dropped.
12305 */
12307
12310 tyinfo->dobj.catId.oid,
12311 false, true);
12312
12314 qualtypname);
12315
12318
12322
12323 /* print subtype_opclass only if not default for subtype */
12325 {
12328
12330 fmtId(nspname));
12332 }
12333
12336 {
12338
12342 }
12343
12347
12351
12353
12357 tyinfo->dobj.namespace->dobj.name);
12358
12362 .namespace = tyinfo->dobj.namespace->dobj.name,
12363 .owner = tyinfo->rolname,
12364 .description = "TYPE",
12365 .section = SECTION_PRE_DATA,
12366 .createStmt = q->data,
12367 .dropStmt = delq->data));
12368
12369 /* Dump Type Comments and Security Labels */
12374
12379
12383 tyinfo->dobj.namespace->dobj.name,
12385
12386 PQclear(res);
12387 destroyPQExpBuffer(q);
12389 destroyPQExpBuffer(query);
12392}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, free, InvalidDumpId, OidIsValid, pg_strdup(), PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPRANGETYPE, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpType().
◆ dumpRelationStats()
|
static |
Definition at line 11392 of file pg_dump.c.
11393{
11395
11396 /* nothing to do if we are not dumping statistics */
11398 return;
11399
11402 .namespace = dobj->namespace->dobj.name,
11403 .description = "STATISTICS DATA",
11404 .section = rsinfo->section,
11405 .defnFn = dumpRelationStats_dumper,
11406 .defnArg = rsinfo,
11407 .deps = dobj->dependencies,
11408 .nDeps = dobj->nDeps));
11409}
References ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), _dumpableObject::dependencies, dumpRelationStats_dumper(), fb(), _dumpableObject::name, _dumpableObject::nDeps, and nilCatalogId.
Referenced by dumpDumpableObject().
◆ dumpRelationStats_dumper()
|
static |
Definition at line 11119 of file pg_dump.c.
11120{
11123 static int rownum;
11124 PQExpBuffer query;
11145
11146 /*
11147 * fetchAttributeStats() assumes that the statistics are dumped in the
11148 * order they are listed in the TOC. We verify that here for safety.
11149 */
11152
11157
11162
11163 query = createPQExpBuffer();
11165 {
11166 appendPQExpBufferStr(query,
11167 "PREPARE getAttributeStats(pg_catalog.name[], pg_catalog.name[]) AS\n"
11168 "SELECT s.schemaname, s.tablename, s.attname, s.inherited, "
11169 "s.null_frac, s.avg_width, s.n_distinct, "
11170 "s.most_common_vals, s.most_common_freqs, "
11171 "s.histogram_bounds, s.correlation, "
11172 "s.most_common_elems, s.most_common_elem_freqs, "
11173 "s.elem_count_histogram, ");
11174
11176 appendPQExpBufferStr(query,
11177 "s.range_length_histogram, "
11178 "s.range_empty_frac, "
11179 "s.range_bounds_histogram ");
11180 else
11181 appendPQExpBufferStr(query,
11182 "NULL AS range_length_histogram,"
11183 "NULL AS range_empty_frac,"
11184 "NULL AS range_bounds_histogram ");
11185
11186 /*
11187 * The results must be in the order of the relations supplied in the
11188 * parameters to ensure we remain in sync as we walk through the TOC.
11189 * The redundant filter clause on s.tablename = ANY(...) seems
11190 * sufficient to convince the planner to use
11191 * pg_class_relname_nsp_index, which avoids a full scan of pg_stats.
11192 * This may not work for all versions.
11193 *
11194 * Our query for retrieving statistics for multiple relations uses
11195 * WITH ORDINALITY and multi-argument UNNEST(), both of which were
11196 * introduced in v9.4. For older versions, we resort to gathering
11197 * statistics for a single relation at a time.
11198 */
11200 appendPQExpBufferStr(query,
11201 "FROM pg_catalog.pg_stats s "
11202 "JOIN unnest($1, $2) WITH ORDINALITY AS u (schemaname, tablename, ord) "
11203 "ON s.schemaname = u.schemaname "
11204 "AND s.tablename = u.tablename "
11205 "WHERE s.tablename = ANY($2) "
11206 "ORDER BY u.ord, s.attname, s.inherited");
11207 else
11208 appendPQExpBufferStr(query,
11209 "FROM pg_catalog.pg_stats s "
11210 "WHERE s.schemaname = $1[1] "
11211 "AND s.tablename = $2[1] "
11212 "ORDER BY s.attname, s.inherited");
11213
11215
11217 resetPQExpBuffer(query);
11218 }
11219
11220 initPQExpBuffer(out);
11221
11222 /* restore relation stats */
11225 fout->remoteVersion);
11233
11234 /*
11235 * Before v14, a reltuples value of 0 was ambiguous: it could either mean
11236 * the relation is empty, or it could mean that it hadn't yet been
11237 * vacuumed or analyzed. (Newer versions use -1 for the latter case.)
11238 * This ambiguity allegedly can cause the planner to choose inefficient
11239 * plans after restoring to v18 or newer. To deal with this, let's just
11240 * set reltuples to -1 in that case.
11241 */
11244 else
11246
11248 rsinfo->relallvisible);
11249
11252
11254
11255 /* Fetch the next batch of attribute statistics if needed. */
11257 {
11258 PQclear(res);
11260 rownum = 0;
11261 }
11262
11280
11281 /* restore attribute stats */
11283 {
11285
11286 /* Stop if the next stat row in our cache isn't for this relation. */
11289 break;
11290
11293 fout->remoteVersion);
11298
11302
11303 /*
11304 * Indexes look up attname in indAttNames to derive attnum, all others
11305 * use attname directly. We must specify attnum for indexes, since
11306 * their attnames are not necessarily stable across dump/reload.
11307 */
11309 {
11312 }
11313 else
11314 {
11315 bool found = false;
11316
11318 {
11320 {
11322 i + 1);
11323 found = true;
11324 break;
11325 }
11326 }
11327
11328 if (!found)
11330 }
11331
11366 {
11376 }
11378 }
11379
11380 destroyPQExpBuffer(query);
11382}
References appendNamedArgument(), appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, attname, createPQExpBuffer(), PQExpBufferData::data, _tocEntry::desc, destroyPQExpBuffer(), _tocEntry::dumpId, ExecuteSqlStatement(), fb(), fetchAttributeStats(), i, initPQExpBuffer(), _tocEntry::next, pg_fatal, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, PREPQUERY_GETATTRIBUTESTATS, REQ_STATS, resetPQExpBuffer(), and _tocEntry::tag.
Referenced by dumpRelationStats().
◆ dumpRule()
Definition at line 19753 of file pg_dump.c.
19754{
19758 PQExpBuffer query;
19759 PQExpBuffer cmd;
19763 PGresult *res;
19764 char *tag;
19765
19766 /* Do nothing if not dumping schema */
19768 return;
19769
19770 /*
19771 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
19772 * we do not want to dump it as a separate object.
19773 */
19775 return;
19776
19777 /*
19778 * If it's an ON SELECT rule, we want to print it as a view definition,
19779 * instead of a rule.
19780 */
19782
19783 query = createPQExpBuffer();
19784 cmd = createPQExpBuffer();
19787
19789
19791 {
19792 PQExpBuffer result;
19793
19794 /*
19795 * We need OR REPLACE here because we'll be replacing a dummy view.
19796 * Otherwise this should look largely like the regular view dump code.
19797 */
19801 {
19805 }
19808 destroyPQExpBuffer(result);
19811 tbinfo->checkoption);
19813 }
19814 else
19815 {
19816 /* In the rule case, just print pg_get_ruledef's result verbatim */
19817 appendPQExpBuffer(query,
19818 "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid)",
19820
19822
19826
19828
19829 PQclear(res);
19830 }
19831
19832 /*
19833 * Add the command to alter the rules replication firing semantics if it
19834 * differs from the default.
19835 */
19837 {
19840 {
19841 case 'A':
19844 break;
19845 case 'R':
19848 break;
19849 case 'D':
19852 break;
19853 }
19854 }
19855
19857 {
19858 /*
19859 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
19860 * REPLACE VIEW to replace the rule with something with minimal
19861 * dependencies.
19862 */
19863 PQExpBuffer result;
19864
19869 destroyPQExpBuffer(result);
19870 }
19871 else
19872 {
19877 }
19878
19881
19883
19886 ARCHIVE_OPTS(.tag = tag,
19888 .owner = tbinfo->rolname,
19889 .description = "RULE",
19890 .section = SECTION_POST_DATA,
19891 .createStmt = cmd->data,
19892 .dropStmt = delcmd->data));
19893
19894 /* Dump rule comments */
19897 tbinfo->dobj.namespace->dobj.name,
19898 tbinfo->rolname,
19900
19901 free(tag);
19902 destroyPQExpBuffer(query);
19903 destroyPQExpBuffer(cmd);
19907}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendReloptionsArrayAH(), ARCHIVE_OPTS, ArchiveEntry(), _dumpableObject::catId, createDummyViewAsClause(), createPQExpBuffer(), createViewAsClause(), PQExpBufferData::data, destroyPQExpBuffer(), _ruleInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, _dumpOptions::dumpSchema, _ruleInfo::ev_enabled, _ruleInfo::ev_type, ExecuteSqlQuery(), fb(), fmtId(), fmtQualifiedDumpable, free, _ruleInfo::is_instead, _dumpableObject::name, nonemptyReloptions(), CatalogId::oid, pg_fatal, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, printfPQExpBuffer(), psprintf(), _ruleInfo::ruletable, SECTION_POST_DATA, and _ruleInfo::separate.
Referenced by dumpDumpableObject().
◆ dumpSearchPath()
Definition at line 3898 of file pg_dump.c.
3899{
3902 PGresult *res;
3906
3907 /*
3908 * We use the result of current_schemas(), not the search_path GUC,
3909 * because that might contain wildcards such as "$user", which won't
3910 * necessarily have the same value during restore. Also, this way avoids
3911 * listing schemas that may appear in search_path but not actually exist,
3912 * which seems like a prudent exclusion.
3913 */
3914 res = ExecuteSqlQueryForSingleRow(AH,
3915 "SELECT pg_catalog.current_schemas(false)");
3916
3919
3920 /*
3921 * We use set_config(), not a simple "SET search_path" command, because
3922 * the latter has less-clean behavior if the search path is empty. While
3923 * that's likely to get fixed at some point, it seems like a good idea to
3924 * be as backwards-compatible as possible in what we put into archives.
3925 */
3927 {
3931 }
3932
3936
3938
3942 .section = SECTION_PRE_DATA,
3943 .createStmt = qry->data));
3944
3945 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3947
3949 PQclear(res);
3950 destroyPQExpBuffer(qry);
3951 destroyPQExpBuffer(path);
3952}
References appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, description, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), free, i, nilCatalogId, parsePGArray(), pg_fatal, pg_log_info, pg_strdup(), PQclear, PQgetvalue, Archive::searchpath, and SECTION_PRE_DATA.
Referenced by main().
◆ dumpSecLabel()
|
static |
Definition at line 16554 of file pg_dump.c.
16557{
16562 PQExpBuffer query;
16563
16564 /* do nothing, if --no-security-labels is supplied */
16566 return;
16567
16568 /*
16569 * Security labels are schema not data ... except large object labels are
16570 * data
16571 */
16573 {
16575 return;
16576 }
16577 else
16578 {
16579 /* We do dump large object security labels in binary-upgrade mode */
16581 return;
16582 }
16583
16584 /* Search for security labels associated with catalogId, using table */
16586
16587 query = createPQExpBuffer();
16588
16590 {
16591 /*
16592 * Ignore label entries for which the subid doesn't match.
16593 */
16595 continue;
16596
16597 appendPQExpBuffer(query,
16598 "SECURITY LABEL FOR %s ON %s ",
16600 if (namespace && *namespace)
16605 }
16606
16608 {
16610
16614 .namespace = namespace,
16615 .owner = owner,
16616 .description = "SECURITY LABEL",
16617 .section = SECTION_NONE,
16618 .createStmt = query->data,
16619 .deps = &dumpId,
16620 .nDeps = 1));
16621 destroyPQExpBuffer(tag);
16622 }
16623
16624 destroyPQExpBuffer(query);
16625}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpData, _dumpOptions::dumpSchema, fb(), findSecLabels(), fmtId(), i, label, PQExpBufferData::len, name, nilCatalogId, _dumpOptions::no_security_labels, CatalogId::oid, SECTION_NONE, CatalogId::tableoid, and type.
Referenced by dumpAgg(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpFunc(), dumpLO(), dumpNamespace(), dumpProcLang(), dumpPublication(), dumpRangeType(), dumpSequence(), dumpSubscription(), and dumpUndefinedType().
◆ dumpSequence()
Definition at line 19194 of file pg_dump.c.
19195{
19200 default_maxv;
19205
19207
19208 /*
19209 * For versions >= 10, the sequence information is gathered in a sorted
19210 * table before any calls to dumpSequence(). See collectSequences() for
19211 * more information.
19212 */
19214 {
19216
19218
19222 }
19223 else
19224 {
19225 PGresult *res;
19226
19227 /*
19228 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
19229 *
19230 * Note: it might seem that 'bigint' potentially needs to be
19231 * schema-qualified, but actually that's a keyword.
19232 */
19233 appendPQExpBuffer(query,
19234 "SELECT 'bigint' AS sequence_type, "
19235 "start_value, increment_by, max_value, min_value, "
19236 "cache_value, is_cycled FROM %s",
19238
19240
19243 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19244 PQntuples(res)),
19246
19255
19256 PQclear(res);
19257 }
19258
19259 /* Calculate default limits for a sequence of this type */
19262 {
19265 }
19267 {
19270 }
19272 {
19275 }
19276 else
19277 {
19280 }
19281
19282 /*
19283 * Identity sequences are not to be dropped separately.
19284 */
19286 {
19289 }
19290
19291 resetPQExpBuffer(query);
19292
19294 {
19296 tbinfo->dobj.catId.oid);
19297
19298 /*
19299 * In older PG versions a sequence will have a pg_type entry, but v14
19300 * and up don't use that, so don't attempt to preserve the type OID.
19301 */
19302 }
19303
19305 {
19307
19308 appendPQExpBuffer(query,
19309 "ALTER TABLE %s ",
19310 fmtQualifiedDumpable(owning_tab));
19311 appendPQExpBuffer(query,
19312 "ALTER COLUMN %s ADD GENERATED ",
19320
19321 /*
19322 * Emit persistence option only if it's different from the owning
19323 * table's. This avoids using this new syntax unnecessarily.
19324 */
19328 "UNLOGGED" : "LOGGED");
19329 }
19330 else
19331 {
19332 appendPQExpBuffer(query,
19333 "CREATE %sSEQUENCE %s\n",
19335 "UNLOGGED " : "",
19337
19340 }
19341
19343
19345
19348 else
19350
19353 else
19355
19356 appendPQExpBuffer(query,
19359
19362 else
19364
19365 /* binary_upgrade: no need to clear TOAST table oid */
19366
19370 tbinfo->dobj.namespace->dobj.name);
19371
19375 .namespace = tbinfo->dobj.namespace->dobj.name,
19376 .owner = tbinfo->rolname,
19377 .description = "SEQUENCE",
19378 .section = SECTION_PRE_DATA,
19379 .createStmt = query->data,
19380 .dropStmt = delqry->data));
19381
19382 /*
19383 * If the sequence is owned by a table column, emit the ALTER for it as a
19384 * separate TOC entry immediately following the sequence's own entry. It's
19385 * OK to do this rather than using full sorting logic, because the
19386 * dependency that tells us it's owned will have forced the table to be
19387 * created first. We can't just include the ALTER in the TOC entry
19388 * because it will fail if we haven't reassigned the sequence owner to
19389 * match the table's owner.
19390 *
19391 * We need not schema-qualify the table reference because both sequence
19392 * and table must be in the same schema.
19393 */
19395 {
19397
19401
19403 {
19404 resetPQExpBuffer(query);
19408 fmtQualifiedDumpable(owning_tab));
19411
19415 .namespace = tbinfo->dobj.namespace->dobj.name,
19416 .owner = tbinfo->rolname,
19417 .description = "SEQUENCE OWNED BY",
19418 .section = SECTION_PRE_DATA,
19419 .createStmt = query->data,
19420 .deps = &(tbinfo->dobj.dumpId),
19421 .nDeps = 1));
19422 }
19423 }
19424
19425 /* Dump Sequence Comments and Security Labels */
19430
19435
19438 destroyPQExpBuffer(query);
19441}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), Assert, _tableInfo::attidentity, _tableInfo::attnames, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpComment(), dumpSecLabel(), ExecuteSqlQuery(), fb(), findTableByOid(), fmtId(), fmtQualifiedDumpable, free, INT64_FORMAT, ngettext, nilCatalogId, nsequences, OidIsValid, parse_sequence_type(), pg_fatal, pg_free(), PG_INT16_MAX, PG_INT16_MIN, PG_INT32_MAX, PG_INT32_MIN, PG_INT64_MAX, PG_INT64_MIN, pg_malloc0(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, _tableInfo::relpersistence, resetPQExpBuffer(), SECTION_PRE_DATA, SEQTYPE_BIGINT, SEQTYPE_INTEGER, SEQTYPE_SMALLINT, SeqTypeNames, SequenceItemCmp(), and sequences.
Referenced by dumpTable().
◆ dumpSequenceData()
|
static |
Definition at line 19448 of file pg_dump.c.
19449{
19451 int64 last;
19453 PQExpBuffer query;
19454
19455 /* needn't bother if not dumping sequence data */
19457 return;
19458
19459 query = createPQExpBuffer();
19460
19461 /*
19462 * For versions >= 18, the sequence information is gathered in the sorted
19463 * array before any calls to dumpSequenceData(). See collectSequences()
19464 * for more information.
19465 *
19466 * For older versions, we have to query the sequence relations
19467 * individually.
19468 */
19470 {
19471 PGresult *res;
19472
19473 appendPQExpBuffer(query,
19474 "SELECT last_value, is_called FROM %s",
19476
19478
19481 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19482 PQntuples(res)),
19484
19487
19488 PQclear(res);
19489 }
19490 else
19491 {
19493 SequenceItem *entry;
19494
19497
19501
19504 "SELECT privilege on the sequence or the sequence may "
19505 "have been concurrently dropped",
19506 tbinfo->dobj.name);
19507
19508 last = entry->last_value;
19510 }
19511
19512 resetPQExpBuffer(query);
19517
19521 .namespace = tbinfo->dobj.namespace->dobj.name,
19522 .owner = tbinfo->rolname,
19523 .description = "SEQUENCE SET",
19524 .section = SECTION_DATA,
19525 .createStmt = query->data,
19526 .deps = &(tbinfo->dobj.dumpId),
19527 .nDeps = 1));
19528
19529 destroyPQExpBuffer(query);
19530}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), Assert, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DATA, ExecuteSqlQuery(), fb(), fmtQualifiedDumpable, INT64_FORMAT, SequenceItem::is_called, SequenceItem::last_value, ngettext, nilCatalogId, nsequences, SequenceItem::null_seqtuple, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, resetPQExpBuffer(), SECTION_DATA, SequenceItemCmp(), and sequences.
Referenced by dumpDumpableObject().
◆ dumpShellType()
|
static |
Definition at line 13237 of file pg_dump.c.
13238{
13240 PQExpBuffer q;
13241
13242 /* Do nothing if not dumping schema */
13244 return;
13245
13246 q = createPQExpBuffer();
13247
13248 /*
13249 * Note the lack of a DROP command for the shell type; any required DROP
13250 * is driven off the base type entry, instead. This interacts with
13251 * _printTocEntry()'s use of the presence of a DROP command to decide
13252 * whether an entry needs an ALTER OWNER command. We don't want to alter
13253 * the shell type's owner immediately on creation; that should happen only
13254 * after it's filled in, otherwise the backend complains.
13255 */
13256
13259 stinfo->baseType->dobj.catId.oid,
13260 false, false);
13261
13264
13268 .namespace = stinfo->dobj.namespace->dobj.name,
13269 .owner = stinfo->baseType->rolname,
13270 .description = "SHELL TYPE",
13271 .section = SECTION_PRE_DATA,
13272 .createStmt = q->data));
13273
13274 destroyPQExpBuffer(q);
13275}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), fmtQualifiedDumpable, and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpStatisticsExt()
|
static |
Definition at line 18477 of file pg_dump.c.
18478{
18480 PQExpBuffer q;
18482 PQExpBuffer query;
18484 PGresult *res;
18486
18487 /* Do nothing if not dumping schema */
18489 return;
18490
18491 q = createPQExpBuffer();
18493 query = createPQExpBuffer();
18494
18496
18498 "pg_catalog.pg_get_statisticsobjdef('%u'::pg_catalog.oid)",
18499 statsextinfo->dobj.catId.oid);
18500
18502
18504
18505 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
18507
18508 /*
18509 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
18510 * for this statistics object is not the default value.
18511 */
18513 {
18517 statsextinfo->stattarget);
18518 }
18519
18522
18525 statsextinfo->dobj.dumpId,
18527 .namespace = statsextinfo->dobj.namespace->dobj.name,
18528 .owner = statsextinfo->rolname,
18529 .description = "STATISTICS",
18530 .section = SECTION_POST_DATA,
18531 .createStmt = q->data,
18532 .dropStmt = delq->data));
18533
18534 /* Dump Statistics Comments */
18537 statsextinfo->dobj.namespace->dobj.name,
18538 statsextinfo->rolname,
18539 statsextinfo->dobj.catId, 0,
18540 statsextinfo->dobj.dumpId);
18541
18542 PQclear(res);
18543 destroyPQExpBuffer(q);
18545 destroyPQExpBuffer(query);
18547}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, pg_strdup(), PQclear, PQgetvalue, and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpStatisticsExtStats()
|
static |
Definition at line 18554 of file pg_dump.c.
18555{
18557 PQExpBuffer query;
18558 PGresult *res;
18559 int nstats;
18560
18561 /* Do nothing if not dumping statistics */
18563 return;
18564
18566 {
18568
18569 /*---------
18570 * Set up query for details about extended statistics objects.
18571 *
18572 * The query depends on the backend version:
18573 * - In v19 and newer versions, query directly the pg_stats_ext*
18574 * catalogs.
18575 * - In v18 and older versions, ndistinct and dependencies have a
18576 * different format that needs translation.
18577 * - In v14 and older versions, inherited does not exist.
18578 * - In v11 and older versions, there is no pg_stats_ext, hence
18579 * the logic joins pg_statistic_ext and pg_namespace.
18580 *---------
18581 */
18582
18584 "PREPARE getExtStatsStats(pg_catalog.name, pg_catalog.name) AS\n"
18585 "SELECT ");
18586
18587 /*
18588 * Versions 15 and newer have inherited stats.
18589 *
18590 * Create this column in all versions because we need to order by it
18591 * later.
18592 */
18595 else
18597
18598 /*--------
18599 * The ndistinct and dependencies formats changed in v19, so
18600 * everything before that needs to be translated.
18601 *
18602 * The ndistinct translation converts this kind of data:
18603 * {"3, 4": 11, "3, 6": 11, "4, 6": 11, "3, 4, 6": 11}
18604 *
18605 * to this:
18606 * [ {"attributes": [3,4], "ndistinct": 11},
18607 * {"attributes": [3,6], "ndistinct": 11},
18608 * {"attributes": [4,6], "ndistinct": 11},
18609 * {"attributes": [3,4,6], "ndistinct": 11} ]
18610 *
18611 * The dependencies translation converts this kind of data:
18612 * {"3 => 4": 1.000000, "3 => 6": 1.000000,
18613 * "4 => 6": 1.000000, "3, 4 => 6": 1.000000,
18614 * "3, 6 => 4": 1.000000}
18615 *
18616 * to this:
18617 * [ {"attributes": [3], "dependency": 4, "degree": 1.000000},
18618 * {"attributes": [3], "dependency": 6, "degree": 1.000000},
18619 * {"attributes": [4], "dependency": 6, "degree": 1.000000},
18620 * {"attributes": [3,4], "dependency": 6, "degree": 1.000000},
18621 * {"attributes": [3,6], "dependency": 4, "degree": 1.000000} ]
18622 *--------
18623 */
18626 else
18628 "( "
18629 "SELECT json_agg( "
18630 " json_build_object( "
18632 " string_to_array(kv.key, ', ')::integer[], "
18634 " kv.value::bigint )) "
18635 "FROM json_each_text(e.n_distinct::text::json) AS kv"
18636 ") AS n_distinct, "
18637 "( "
18638 "SELECT json_agg( "
18639 " json_build_object( "
18641 " string_to_array( "
18642 " split_part(kv.key, ' => ', 1), "
18643 " ', ')::integer[], "
18645 " split_part(kv.key, ' => ', 2)::integer, "
18647 " kv.value::double precision )) "
18648 "FROM json_each_text(e.dependencies::text::json) AS kv "
18649 ") AS dependencies ");
18650
18651 /* pg_stats_ext introduced in v12 */
18654 "FROM pg_catalog.pg_stats_ext AS e "
18655 "WHERE e.statistics_schemaname = $1 "
18656 "AND e.statistics_name = $2 ");
18657 else
18659 "FROM ( "
18660 "SELECT s.stxndistinct AS n_distinct, "
18661 " s.stxdependencies AS dependencies "
18662 "FROM pg_catalog.pg_statistic_ext AS s "
18663 "JOIN pg_catalog.pg_namespace AS n "
18664 "ON n.oid = s.stxnamespace "
18665 "WHERE n.nspname = $1 "
18666 "AND s.stxname = $2 "
18667 ") AS e ");
18668
18669 /* we always have an inherited column, but it may be a constant */
18671
18673
18675
18677 }
18678
18679 query = createPQExpBuffer();
18680
18686
18688
18689 destroyPQExpBuffer(query);
18690
18691 nstats = PQntuples(res);
18692
18693 if (nstats > 0)
18694 {
18696
18700
18702 {
18704
18707
18708 appendPQExpBufferStr(out,
18709 "SELECT * FROM pg_catalog.pg_restore_extended_stats(\n");
18711 fout->remoteVersion);
18712
18713 /* Relation information */
18718
18719 /* Extended statistics information */
18726
18730
18734
18736 }
18737
18740 .namespace = statsextinfo->dobj.namespace->dobj.name,
18741 .owner = statsextinfo->rolname,
18742 .description = "EXTENDED STATISTICS DATA",
18743 .section = SECTION_POST_DATA,
18744 .createStmt = out->data,
18745 .deps = &statsextinfo->dobj.dumpId,
18746 .nDeps = 1));
18747 destroyPQExpBuffer(out);
18748 }
18749 PQclear(res);
18750}
References appendNamedArgument(), appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpStatistics, ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), i, nilCatalogId, PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, PG_DEPENDENCIES_KEY_DEPENDENCY, pg_fatal, PG_NDISTINCT_KEY_ATTRIBUTES, PG_NDISTINCT_KEY_NDISTINCT, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, PREPQUERY_DUMPEXTSTATSOBJSTATS, and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpStdStrings()
Definition at line 3874 of file pg_dump.c.
3875{
3878
3880 stdstrings);
3881
3883 stdstrings);
3884
3888 .section = SECTION_PRE_DATA,
3889 .createStmt = qry->data));
3890
3891 destroyPQExpBuffer(qry);
3892}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, description, destroyPQExpBuffer(), fb(), nilCatalogId, pg_log_info, SECTION_PRE_DATA, and Archive::std_strings.
Referenced by main().
◆ dumpSubscription()
|
static |
Definition at line 5496 of file pg_dump.c.
5497{
5500 PQExpBuffer query;
5501 PQExpBuffer publications;
5506
5507 /* Do nothing if not dumping schema */
5509 return;
5510
5512 query = createPQExpBuffer();
5513
5515
5517 qsubname);
5518
5520 qsubname);
5522
5523 /* Build list of quoted publications and append them to query. */
5526
5527 publications = createPQExpBuffer();
5529 {
5532
5534 }
5535
5536 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
5539 else
5541
5544
5549 else
5551
5554
5557
5560
5563
5566
5569
5572
5575
5578
5580
5581 /*
5582 * In binary-upgrade mode, we allow the replication to continue after the
5583 * upgrade.
5584 */
5586 {
5588 {
5589 /*
5590 * Preserve the remote_lsn for the subscriber's replication
5591 * origin. This value is required to start the replication from
5592 * the position before the upgrade. This value will be stale if
5593 * the publisher gets upgraded before the subscriber node.
5594 * However, this shouldn't be a problem as the upgrade of the
5595 * publisher ensures that all the transactions were replicated
5596 * before upgrading it.
5597 */
5598 appendPQExpBufferStr(query,
5599 "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
5600 appendPQExpBufferStr(query,
5601 "SELECT pg_catalog.binary_upgrade_replorigin_advance(");
5604 }
5605
5607 {
5608 /*
5609 * Enable the subscription to allow the replication to continue
5610 * after the upgrade.
5611 */
5612 appendPQExpBufferStr(query,
5613 "\n-- For binary upgrade, must preserve the subscriber's running state.\n");
5615 }
5616 }
5617
5621 .owner = subinfo->rolname,
5622 .description = "SUBSCRIPTION",
5623 .section = SECTION_POST_DATA,
5624 .createStmt = query->data,
5625 .dropStmt = delq->data));
5626
5631
5636
5637 destroyPQExpBuffer(publications);
5639
5641 destroyPQExpBuffer(query);
5643}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _SubscriptionInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpComment(), _dumpableObject::dumpId, _dumpOptions::dumpSchema, dumpSecLabel(), fb(), fmtId(), free, i, _dumpableObject::name, parsePGArray(), pg_fatal, pg_strcasecmp(), pg_strdup(), _SubscriptionInfo::rolname, SECTION_POST_DATA, _SubscriptionInfo::subbinary, _SubscriptionInfo::subconninfo, _SubscriptionInfo::subdisableonerr, _SubscriptionInfo::subenabled, _SubscriptionInfo::subfailover, _SubscriptionInfo::submaxretention, _SubscriptionInfo::suborigin, _SubscriptionInfo::suboriginremotelsn, _SubscriptionInfo::subpasswordrequired, _SubscriptionInfo::subpublications, _SubscriptionInfo::subretaindeadtuples, _SubscriptionInfo::subrunasowner, _SubscriptionInfo::subslotname, _SubscriptionInfo::substream, _SubscriptionInfo::subsynccommit, and _SubscriptionInfo::subtwophasestate.
Referenced by dumpDumpableObject().
◆ dumpSubscriptionTable()
|
static |
Definition at line 5427 of file pg_dump.c.
5428{
5431 PQExpBuffer query;
5432 char *tag;
5433
5434 /* Do nothing if not dumping schema */
5436 return;
5437
5439
5441
5442 query = createPQExpBuffer();
5443
5445 {
5446 /*
5447 * binary_upgrade_add_sub_rel_state will add the subscription relation
5448 * to pg_subscription_rel table. This will be used only in
5449 * binary-upgrade mode.
5450 */
5451 appendPQExpBufferStr(query,
5452 "\n-- For binary upgrade, must preserve the subscriber table.\n");
5453 appendPQExpBufferStr(query,
5454 "SELECT pg_catalog.binary_upgrade_add_sub_rel_state(");
5456 appendPQExpBuffer(query,
5457 ", %u, '%c'",
5458 subrinfo->tblinfo->dobj.catId.oid,
5459 subrinfo->srsubstate);
5460
5463 else
5465
5467 }
5468
5469 /*
5470 * There is no point in creating a drop query as the drop is done by table
5471 * drop. (If you think to change this, see also _printTocEntry().)
5472 * Although this object doesn't really have ownership as such, set the
5473 * owner field anyway to ensure that the command is run by the correct
5474 * role at restore time.
5475 */
5478 ARCHIVE_OPTS(.tag = tag,
5480 .owner = subinfo->rolname,
5481 .description = "SUBSCRIPTION TABLE",
5482 .section = SECTION_POST_DATA,
5483 .createStmt = query->data));
5484
5485 /* These objects can't currently have comments or seclabels */
5486
5487 free(tag);
5488 destroyPQExpBuffer(query);
5489}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _SubscriptionInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), free, _dumpableObject::name, psprintf(), _SubscriptionInfo::rolname, and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpTable()
Definition at line 16881 of file pg_dump.c.
16882{
16886
16887 /* Do nothing if not dumping schema */
16889 return;
16890
16892 {
16895 else
16897 }
16898
16899 /* Handle the ACL here */
16902 {
16903 const char *objtype =
16905
16906 tableAclDumpId =
16909 tbinfo->dobj.namespace->dobj.name,
16911 }
16912
16913 /*
16914 * Handle column ACLs, if any. Note: we pull these with a separate query
16915 * rather than trying to fetch them during getTableAttrs, so that we won't
16916 * miss ACLs on system columns. Doing it this way also allows us to dump
16917 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
16918 */
16920 {
16922 PGresult *res;
16924
16926 {
16927 /* Set up query for column ACLs */
16928 appendPQExpBufferStr(query,
16929 "PREPARE getColumnACLs(pg_catalog.oid) AS\n");
16930
16932 {
16933 /*
16934 * In principle we should call acldefault('c', relowner) to
16935 * get the default ACL for a column. However, we don't
16936 * currently store the numeric OID of the relowner in
16937 * TableInfo. We could convert the owner name using regrole,
16938 * but that creates a risk of failure due to concurrent role
16939 * renames. Given that the default ACL for columns is empty
16940 * and is likely to stay that way, it's not worth extra cycles
16941 * and risk to avoid hard-wiring that knowledge here.
16942 */
16943 appendPQExpBufferStr(query,
16944 "SELECT at.attname, "
16945 "at.attacl, "
16946 "'{}' AS acldefault, "
16947 "pip.privtype, pip.initprivs "
16948 "FROM pg_catalog.pg_attribute at "
16949 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
16950 "(at.attrelid = pip.objoid "
16951 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
16952 "AND at.attnum = pip.objsubid) "
16953 "WHERE at.attrelid = $1 AND "
16954 "NOT at.attisdropped "
16955 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
16956 "ORDER BY at.attnum");
16957 }
16958 else
16959 {
16960 appendPQExpBufferStr(query,
16961 "SELECT attname, attacl, '{}' AS acldefault, "
16962 "NULL AS privtype, NULL AS initprivs "
16963 "FROM pg_catalog.pg_attribute "
16964 "WHERE attrelid = $1 AND NOT attisdropped "
16965 "AND attacl IS NOT NULL "
16966 "ORDER BY attnum");
16967 }
16968
16970
16972 }
16973
16974 printfPQExpBuffer(query,
16975 "EXECUTE getColumnACLs('%u')",
16976 tbinfo->dobj.catId.oid);
16977
16979
16981 {
16989
16992 coldacl.privtype = privtype;
16993 coldacl.initprivs = initprivs;
16995
16996 /*
16997 * Column's GRANT type is always TABLE. Each column ACL depends
16998 * on the table-level ACL, since we can restore column ACLs in
16999 * parallel but the table-level ACL has to be done first.
17000 */
17003 tbinfo->dobj.namespace->dobj.name,
17006 }
17007 PQclear(res);
17008 destroyPQExpBuffer(query);
17009 }
17010
17012}
References _dumpableAcl::acl, acldefault(), appendPQExpBufferStr(), attname, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_DEFINITION, dumpACL(), _dumpOptions::dumpSchema, dumpSequence(), dumpTableSchema(), ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), fmtId(), free, i, InvalidDumpId, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, PREPQUERY_GETCOLUMNACLS, and printfPQExpBuffer().
Referenced by dumpDumpableObject().
◆ dumpTableAttach()
|
static |
Definition at line 18125 of file pg_dump.c.
18126{
18128 PQExpBuffer q;
18129 PGresult *res;
18130 char *partbound;
18131
18132 /* Do nothing if not dumping schema */
18134 return;
18135
18136 q = createPQExpBuffer();
18137
18139 {
18140 /* Set up query for partbound details */
18141 appendPQExpBufferStr(q,
18142 "PREPARE dumpTableAttach(pg_catalog.oid) AS\n");
18143
18144 appendPQExpBufferStr(q,
18145 "SELECT pg_get_expr(c.relpartbound, c.oid) "
18146 "FROM pg_class c "
18147 "WHERE c.oid = $1");
18148
18150
18152 }
18153
18154 printfPQExpBuffer(q,
18155 "EXECUTE dumpTableAttach('%u')",
18156 attachinfo->partitionTbl->dobj.catId.oid);
18157
18159 partbound = PQgetvalue(res, 0, 0);
18160
18161 /* Perform ALTER TABLE on the parent */
18162 printfPQExpBuffer(q,
18163 "ALTER TABLE ONLY %s ",
18165 appendPQExpBuffer(q,
18166 "ATTACH PARTITION %s %s;\n",
18168 partbound);
18169
18170 /*
18171 * There is no point in creating a drop query as the drop is done by table
18172 * drop. (If you think to change this, see also _printTocEntry().)
18173 * Although this object doesn't really have ownership as such, set the
18174 * owner field anyway to ensure that the command is run by the correct
18175 * role at restore time.
18176 */
18179 .namespace = attachinfo->dobj.namespace->dobj.name,
18180 .owner = attachinfo->partitionTbl->rolname,
18181 .description = "TABLE ATTACH",
18182 .section = SECTION_PRE_DATA,
18183 .createStmt = q->data));
18184
18185 PQclear(res);
18186 destroyPQExpBuffer(q);
18187}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtQualifiedDumpable, PQclear, PQgetvalue, PREPQUERY_DUMPTABLEATTACH, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpTableComment()
|
static |
Definition at line 11418 of file pg_dump.c.
11420{
11424 PQExpBuffer query;
11425 PQExpBuffer tag;
11426
11427 /* do nothing, if --no-comments is supplied */
11429 return;
11430
11431 /* Comments are SCHEMA not data */
11433 return;
11434
11435 /* Search for comments associated with relation, using table */
11437 tbinfo->dobj.catId.oid,
11438 &comments);
11439
11440 /* If comments exist, build COMMENT ON statements */
11442 return;
11443
11444 query = createPQExpBuffer();
11445 tag = createPQExpBuffer();
11446
11448 {
11451
11452 if (objsubid == 0)
11453 {
11454 resetPQExpBuffer(tag);
11457
11458 resetPQExpBuffer(query);
11463
11466 .namespace = tbinfo->dobj.namespace->dobj.name,
11467 .owner = tbinfo->rolname,
11468 .description = "COMMENT",
11469 .section = SECTION_NONE,
11470 .createStmt = query->data,
11471 .deps = &(tbinfo->dobj.dumpId),
11472 .nDeps = 1));
11473 }
11475 {
11476 resetPQExpBuffer(tag);
11480
11481 resetPQExpBuffer(query);
11488
11491 .namespace = tbinfo->dobj.namespace->dobj.name,
11492 .owner = tbinfo->rolname,
11493 .description = "COMMENT",
11494 .section = SECTION_NONE,
11495 .createStmt = query->data,
11496 .deps = &(tbinfo->dobj.dumpId),
11497 .nDeps = 1));
11498 }
11499
11500 comments++;
11501 ncomments--;
11502 }
11503
11504 destroyPQExpBuffer(query);
11505 destroyPQExpBuffer(tag);
11506}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), comments, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), _dumpOptions::dumpSchema, fb(), findComments(), fmtId(), fmtQualifiedDumpable, ncomments, nilCatalogId, _dumpOptions::no_comments, CommentItem::objsubid, resetPQExpBuffer(), and SECTION_NONE.
Referenced by dumpTableSchema().
◆ dumpTableConstraintComment()
|
static |
Definition at line 19078 of file pg_dump.c.
19079{
19083
19085
19088
19091 tbinfo->dobj.namespace->dobj.name,
19092 tbinfo->rolname,
19093 coninfo->dobj.catId, 0,
19095
19098}
References appendPQExpBuffer(), createPQExpBuffer(), destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, dumpComment(), fb(), fmtId(), free, and pg_strdup().
Referenced by dumpConstraint(), and dumpTableSchema().
◆ dumpTableData()
|
static |
Definition at line 2884 of file pg_dump.c.
2885{
2890 DataDumperPtr dumpFn;
2892 char *copyStmt;
2894
2895 /* We had better have loaded per-column details about this table */
2897
2898 /*
2899 * When load-via-partition-root is set or forced, get the root table name
2900 * for the partition table, so that we can reload data through the root
2901 * table. Then construct a comment to be inserted into the TOC entry's
2902 * defn field, so that such cases can be identified reliably.
2903 */
2905 (dopt->load_via_partition_root ||
2907 {
2910
2915 sanitized);
2918 }
2919 else
2921
2923 {
2924 /* Dump/restore using COPY */
2925 dumpFn = dumpTableData_copy;
2926 /* must use 2 steps here 'cause fmtId is nonreentrant */
2928 copyFrom);
2931 copyStmt = copyBuf->data;
2932 }
2933 else
2934 {
2935 /* Restore using INSERT */
2936 dumpFn = dumpTableData_insert;
2937 copyStmt = NULL;
2938 }
2939
2940 /*
2941 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2942 * dependency on its table as "special" and pass it to ArchiveEntry now.
2943 * See comments for BuildArchiveDependencies.
2944 */
2946 {
2947 TocEntry *te;
2948
2951 .namespace = tbinfo->dobj.namespace->dobj.name,
2952 .owner = tbinfo->rolname,
2953 .description = "TABLE DATA",
2954 .section = SECTION_DATA,
2955 .createStmt = tdDefn,
2956 .copyStmt = copyStmt,
2957 .deps = &(tbinfo->dobj.dumpId),
2958 .nDeps = 1,
2959 .dumpFn = dumpFn,
2960 .dumpArg = tdinfo));
2961
2962 /*
2963 * Set the TocEntry's dataLength in case we are doing a parallel dump
2964 * and want to order dump jobs by table size. We choose to measure
2965 * dataLength in table pages (including TOAST pages) during dump, so
2966 * no scaling is needed.
2967 *
2968 * However, relpages is declared as "integer" in pg_class, and hence
2969 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2970 * Cast so that we get the right interpretation of table sizes
2971 * exceeding INT_MAX pages.
2972 */
2975
2976 /*
2977 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2978 * and instead we'd better worry about integer overflow. Clamp to
2979 * INT_MAX if the correct result exceeds that.
2980 */
2981 if (sizeof(te->dataLength) == 4 &&
2983 te->dataLength < 0))
2984 te->dataLength = INT_MAX;
2985 }
2986
2989}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), Assert, createPQExpBuffer(), _tocEntry::dataLength, destroyPQExpBuffer(), DUMP_COMPONENT_DATA, _dumpOptions::dump_inserts, dumpTableData_copy(), dumpTableData_insert(), fb(), fmtCopyColumnList(), fmtQualifiedDumpable, forcePartitionRootLoad(), free, getRootTableInfo(), _dumpOptions::load_via_partition_root, pg_strdup(), printfPQExpBuffer(), sanitize_line(), and SECTION_DATA.
Referenced by dumpDumpableObject().
◆ dumpTableData_copy()
Definition at line 2394 of file pg_dump.c.
2395{
2400
2401 /*
2402 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2403 * which uses it already.
2404 */
2407 PGresult *res;
2408 int ret;
2411
2413 tbinfo->dobj.namespace->dobj.name, classname);
2414
2415 /*
2416 * Specify the column list explicitly so that we have no possibility of
2417 * retrieving data in the wrong column order. (The default column
2418 * ordering of COPY will not be what we want in certain corner cases
2419 * involving ADD COLUMN and inheritance.)
2420 */
2422
2423 /*
2424 * Use COPY (SELECT ...) TO when dumping a foreign table's data, and when
2425 * a filter condition was specified. For other cases a simple COPY
2426 * suffices.
2427 */
2429 {
2430 /* Temporary allows to access to foreign tables to dump data */
2433
2435 /* klugery to get rid of parens in column list */
2437 {
2440 }
2441 else
2443
2447 }
2448 else
2449 {
2452 column_list);
2453 }
2455 PQclear(res);
2457
2458 for (;;)
2459 {
2461
2462 if (ret < 0)
2463 break; /* done or error */
2464
2466 {
2469 }
2470
2471 /* ----------
2472 * THROTTLE:
2473 *
2474 * There was considerable discussion in late July, 2000 regarding
2475 * slowing down pg_dump when backing up large tables. Users with both
2476 * slow & fast (multi-processor) machines experienced performance
2477 * degradation when doing a backup.
2478 *
2479 * Initial attempts based on sleeping for a number of ms for each ms
2480 * of work were deemed too complex, then a simple 'sleep in each loop'
2481 * implementation was suggested. The latter failed because the loop
2482 * was too tight. Finally, the following was implemented:
2483 *
2484 * If throttle is non-zero, then
2485 * See how long since the last sleep.
2486 * Work out how long to sleep (based on ratio).
2487 * If sleep is more than 100ms, then
2488 * sleep
2489 * reset timer
2490 * EndIf
2491 * EndIf
2492 *
2493 * where the throttle value was the number of ms to sleep per ms of
2494 * work. The calculation was done in each loop.
2495 *
2496 * Most of the hard work is done in the backend, and this solution
2497 * still did not work particularly well: on slow machines, the ratio
2498 * was 50:1, and on medium paced machines, 1:1, and on fast
2499 * multi-processor machines, it had little or no effect, for reasons
2500 * that were unclear.
2501 *
2502 * Further discussion ensued, and the proposal was dropped.
2503 *
2504 * For those people who want this feature, it can be implemented using
2505 * gettimeofday in each loop, calculating the time since last sleep,
2506 * multiplying that by the sleep ratio, then if the result is more
2507 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2508 * function to sleep for a subsecond period ie.
2509 *
2510 * select(0, NULL, NULL, NULL, &tvi);
2511 *
2512 * This will return after the interval specified in the structure tvi.
2513 * Finally, call gettimeofday again to save the 'last sleep time'.
2514 * ----------
2515 */
2516 }
2518
2519 if (ret == -2)
2520 {
2521 /* copy data transfer failed */
2522 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2525 exit_nicely(1);
2526 }
2527
2528 /* Check command status and return to normal libpq state */
2531 {
2535 exit_nicely(1);
2536 }
2537 PQclear(res);
2538
2539 /* Do this to ensure we've pumped libpq back to idle state */
2542 classname);
2543
2544 destroyPQExpBuffer(q);
2545
2546 /* Revert back the setting */
2549
2550 return 1;
2551}
References appendPQExpBuffer(), appendPQExpBufferStr(), archprintf(), conn, copybuf, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, ExecuteSqlQuery(), exit_nicely(), fb(), fmtCopyColumnList(), fmtQualifiedDumpable, GetConnection(), PQExpBufferData::len, _dumpableObject::name, pg_log_error, pg_log_error_detail, pg_log_info, pg_log_warning, PGRES_COMMAND_OK, PGRES_COPY_OUT, PQclear, PQerrorMessage(), PQfreemem(), PQgetCopyData(), PQgetResult, PQresultStatus, set_restrict_relation_kind(), and WriteData().
Referenced by dumpTableData().
◆ dumpTableData_insert()
Definition at line 2562 of file pg_dump.c.
2563{
2569 char *attgenerated;
2570 PGresult *res;
2571 int nfields,
2572 i;
2575
2576 /* Temporary allows to access to foreign tables to dump data */
2579
2580 /*
2581 * If we're going to emit INSERTs with column names, the most efficient
2582 * way to deal with generated columns is to exclude them entirely. For
2583 * INSERTs without column names, we have to emit DEFAULT rather than the
2584 * actual column value --- but we can save a few cycles by fetching nulls
2585 * rather than the uninteresting-to-us value.
2586 */
2589 nfields = 0;
2591 {
2593 continue;
2595 continue;
2596 if (nfields > 0)
2600 else
2603 nfields++;
2604 }
2605 /* Servers before 9.4 will complain about zero-column SELECT */
2606 if (nfields == 0)
2612
2614
2615 while (1)
2616 {
2618 PGRES_TUPLES_OK);
2619
2620 /* cross-check field count, allowing for dummy NULL if any */
2622 !(nfields == 0 && PQnfields(res) == 1))
2624 tbinfo->dobj.name);
2625
2626 /*
2627 * First time through, we build as much of the INSERT statement as
2628 * possible in "insertStmt", which we can then just print for each
2629 * statement. If the table happens to have zero dumpable columns then
2630 * this will be a complete statement, otherwise it will end in
2631 * "VALUES" and be ready to have the row's column values printed.
2632 */
2634 {
2636
2638
2639 /*
2640 * When load-via-partition-root is set or forced, get the root
2641 * table name for the partition table, so that we can reload data
2642 * through the root table.
2643 */
2645 (dopt->load_via_partition_root ||
2648 else
2650
2653
2654 /* corner case for zero-column table */
2655 if (nfields == 0)
2656 {
2658 }
2659 else
2660 {
2661 /* append the list of column names if required */
2663 {
2665 for (int field = 0; field < nfields; field++)
2666 {
2667 if (field > 0)
2671 }
2673 }
2674
2677
2679 }
2680 }
2681
2683 {
2684 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2687
2688 /*
2689 * If it is zero-column table then we've already written the
2690 * complete statement, which will mean we've disobeyed
2691 * --rows-per-insert when it's set greater than 1. We do support
2692 * a way to make this multi-row with: SELECT UNION ALL SELECT
2693 * UNION ALL ... but that's non-standard so we should avoid it
2694 * given that using INSERTs is mostly only ever needed for
2695 * cross-database exports.
2696 */
2697 if (nfields == 0)
2698 continue;
2699
2700 /* Emit a row heading */
2705 else
2707
2708 for (int field = 0; field < nfields; field++)
2709 {
2710 if (field > 0)
2712 if (attgenerated[field])
2713 {
2715 continue;
2716 }
2718 {
2720 continue;
2721 }
2722
2723 /* XXX This code is partially duplicated in ruleutils.c */
2725 {
2733 {
2734 /*
2735 * These types are printed without quotes unless
2736 * they contain values that aren't accepted by the
2737 * scanner unquoted (e.g., 'NaN'). Note that
2738 * strtod() and friends might accept NaN, so we
2739 * can't use that to test.
2740 *
2741 * In reality we only need to defend against
2742 * infinity and NaN, so we need not get too crazy
2743 * about pattern matching here.
2744 */
2746
2749 else
2751 }
2752 break;
2753
2757 PQgetvalue(res, tuple, field));
2758 break;
2759
2763 else
2765 break;
2766
2767 default:
2768 /* All other types are printed as string literals. */
2769 resetPQExpBuffer(q);
2770 appendStringLiteralAH(q,
2771 PQgetvalue(res, tuple, field),
2772 fout);
2774 break;
2775 }
2776 }
2777
2778 /* Terminate the row ... */
2780
2781 /* ... and the statement, if the target no. of rows is reached */
2783 {
2786 else
2788 /* Reset the row counter */
2789 rows_this_statement = 0;
2790 }
2791 }
2792
2794 {
2795 PQclear(res);
2796 break;
2797 }
2798 PQclear(res);
2799 }
2800
2801 /* Terminate any statements that didn't make the row count. */
2803 {
2806 else
2808 }
2809
2811
2813
2814 destroyPQExpBuffer(q);
2817 free(attgenerated);
2818
2819 /* Revert back the setting */
2822
2823 return 1;
2824}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, archprintf(), archputs(), _dumpOptions::column_inserts, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::do_nothing, _dumpOptions::dump_inserts, ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), fmtId(), fmtQualifiedDumpable, forcePartitionRootLoad(), free, getRootTableInfo(), i, _dumpOptions::load_via_partition_root, pg_fatal, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQfname, PQftype(), PQgetisnull, PQgetvalue, PQnfields, PQntuples, resetPQExpBuffer(), and set_restrict_relation_kind().
Referenced by dumpTableData().
◆ dumpTableSchema()
Definition at line 17110 of file pg_dump.c.
17111{
17118 int numParents;
17119 TableInfo **parents;
17124 k;
17125
17126 /* We had better have loaded per-column details about this table */
17128
17131
17134 qrelname);
17135
17138
17139 /* Is it a table or a view? */
17141 {
17142 PQExpBuffer result;
17143
17144 /*
17145 * Note: keep this code in sync with the is_view case in dumpRule()
17146 */
17147
17149
17151
17154 tbinfo->dobj.catId.oid);
17155
17157
17160 else
17161 {
17163 {
17167 }
17169 }
17171 destroyPQExpBuffer(result);
17172
17176 }
17177 else
17178 {
17183
17184 /*
17185 * Set reltypename, and collect any relkind-specific data that we
17186 * didn't fetch during getTables().
17187 */
17189 {
17191 {
17193 PGresult *res;
17194
17196
17197 /* retrieve partition key definition */
17198 appendPQExpBuffer(query,
17199 "SELECT pg_get_partkeydef('%u')",
17200 tbinfo->dobj.catId.oid);
17203 PQclear(res);
17204 destroyPQExpBuffer(query);
17205 break;
17206 }
17208 {
17210 PGresult *res;
17213
17215
17216 /* retrieve name of foreign server and generic options */
17217 appendPQExpBuffer(query,
17218 "SELECT fs.srvname, "
17219 "pg_catalog.array_to_string(ARRAY("
17220 "SELECT pg_catalog.quote_ident(option_name) || "
17221 "' ' || pg_catalog.quote_literal(option_value) "
17222 "FROM pg_catalog.pg_options_to_table(ftoptions) "
17223 "ORDER BY option_name"
17224 "), E',\n ') AS ftoptions "
17225 "FROM pg_catalog.pg_foreign_table ft "
17226 "JOIN pg_catalog.pg_foreign_server fs "
17227 "ON (fs.oid = ft.ftserver) "
17228 "WHERE ft.ftrelid = '%u'",
17229 tbinfo->dobj.catId.oid);
17235 PQclear(res);
17236 destroyPQExpBuffer(query);
17237
17239 break;
17240 }
17243 break;
17244 default:
17246 break;
17247 }
17248
17249 numParents = tbinfo->numParents;
17251
17253
17256 tbinfo->dobj.catId.oid);
17257
17258 /*
17259 * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
17260 * ignore it when dumping if it was set in this case.
17261 */
17265 "UNLOGGED " : "",
17266 reltypename,
17267 qualrelname);
17268
17269 /*
17270 * Attach to type, if reloftype; except in case of a binary upgrade,
17271 * we dump the table normally and attach it to the type afterward.
17272 */
17276 zeroIsError));
17277
17279 {
17280 /* Dump the attributes */
17281 actual_atts = 0;
17283 {
17284 /*
17285 * Normally, dump if it's locally defined in this table, and
17286 * not dropped. But for binary upgrade, we'll dump all the
17287 * columns, and then fix up the dropped and nonlocal cases
17288 * below.
17289 */
17291 {
17294
17295 /*
17296 * Default value --- suppress if to be printed separately
17297 * or not at all.
17298 */
17302
17303 /*
17304 * Not Null constraint --- print it if it is locally
17305 * defined, or if binary upgrade. (In the latter case, we
17306 * reset conislocal below.)
17307 */
17310 dopt->binary_upgrade ||
17311 tbinfo->ispartition));
17312
17313 /*
17314 * Skip column if fully defined by reloftype, except in
17315 * binary upgrade
17316 */
17319 !dopt->binary_upgrade)
17320 continue;
17321
17322 /* Format properly if not first attr */
17325 else
17328 actual_atts++;
17329
17330 /* Attribute name */
17332
17334 {
17335 /*
17336 * ALTER TABLE DROP COLUMN clears
17337 * pg_attribute.atttypid, so we will not have gotten a
17338 * valid type name; insert INTEGER as a stopgap. We'll
17339 * clean things up later.
17340 */
17342 /* and skip to the next column */
17343 continue;
17344 }
17345
17346 /*
17347 * Attribute type; print it except when creating a typed
17348 * table ('OF type_name'), but in binary-upgrade mode,
17349 * print it in that case too.
17350 */
17352 {
17355 }
17356
17358 {
17365 else
17368 }
17369
17371 {
17374 else
17377
17380 }
17381
17382 /* Add collation if not default for the type */
17384 {
17386
17391 }
17392 }
17393
17394 /*
17395 * On the other hand, if we choose not to print a column
17396 * (likely because it is created by inheritance), but the
17397 * column has a locally-defined not-null constraint, we need
17398 * to dump the constraint as a standalone object.
17399 *
17400 * This syntax isn't SQL-conforming, but if you wanted
17401 * standard output you wouldn't be creating non-standard
17402 * objects to begin with.
17403 */
17408 {
17409 /* Format properly if not first attr */
17412 else
17415 actual_atts++;
17416
17420 else
17424 }
17425 }
17426
17427 /*
17428 * Add non-inherited CHECK constraints, if any.
17429 *
17430 * For partitions, we need to include check constraints even if
17431 * they're not defined locally, because the ALTER TABLE ATTACH
17432 * PARTITION that we'll emit later expects the constraint to be
17433 * there. (No need to fix conislocal: ATTACH PARTITION does that)
17434 */
17436 {
17438
17441 continue;
17442
17445 else
17447
17451
17452 actual_atts++;
17453 }
17454
17458 {
17459 /*
17460 * No attributes? we must have a parenthesized attribute list,
17461 * even though empty, when not using the OF TYPE syntax.
17462 */
17464 }
17465
17466 /*
17467 * Emit the INHERITS clause (not for partitions), except in
17468 * binary-upgrade mode.
17469 */
17471 !dopt->binary_upgrade)
17472 {
17474 for (k = 0; k < numParents; k++)
17475 {
17477
17478 if (k > 0)
17481 }
17483 }
17484
17487
17490 }
17491
17494 {
17496
17499 {
17502 }
17504 {
17508 fout);
17509 }
17511 }
17512
17513 /* Dump generic options if any */
17516
17517 /*
17518 * For materialized views, create the AS clause just like a view. At
17519 * this point, we always mark the view as not populated.
17520 */
17522 {
17523 PQExpBuffer result;
17524
17527 result->data);
17528 destroyPQExpBuffer(result);
17529 }
17530 else
17532
17533 /* Materialized views can depend on extensions */
17536 "pg_catalog.pg_class",
17537 "MATERIALIZED VIEW",
17538 qualrelname);
17539
17540 /*
17541 * in binary upgrade mode, update the catalog with any missing values
17542 * that might be present.
17543 */
17545 {
17547 {
17549 {
17551 appendPQExpBufferStr(q,
17552 "SELECT pg_catalog.binary_upgrade_set_missing_value(");
17559 }
17560 }
17561 }
17562
17563 /*
17564 * To create binary-compatible heap files, we have to ensure the same
17565 * physical column order, including dropped columns, as in the
17566 * original. Therefore, we create dropped columns above and drop them
17567 * here, also updating their attlen/attalign values so that the
17568 * dropped column can be skipped properly. (We do not bother with
17569 * restoring the original attbyval setting.) Also, inheritance
17570 * relationships are set up by doing ALTER TABLE INHERIT rather than
17571 * using an INHERITS clause --- the latter would possibly mess up the
17572 * column order. That also means we have to take care about setting
17573 * attislocal correctly, plus fix up any inherited CHECK constraints.
17574 * Analogously, we set up typed tables using ALTER TABLE / OF here.
17575 *
17576 * We process foreign and partitioned tables here, even though they
17577 * lack heap storage, because they can participate in inheritance
17578 * relationships and we want this stuff to be consistent across the
17579 * inheritance tree. We can exclude indexes, toast tables, sequences
17580 * and matviews, even though they have storage, because we don't
17581 * support altering or dropping columns in them, nor can they be part
17582 * of inheritance trees.
17583 */
17588 {
17591
17592 /*
17593 * Drop any dropped columns. Merge the pg_attribute manipulations
17594 * into a single SQL command, so that we don't cause repeated
17595 * relcache flushes on the target table. Otherwise we risk O(N^2)
17596 * relcache bloat while dropping N columns.
17597 */
17598 resetPQExpBuffer(extra);
17601 {
17603 {
17605 {
17607 "UPDATE pg_catalog.pg_attribute\n"
17608 "SET attlen = v.dlen, "
17609 "attalign = v.dalign, "
17610 "attbyval = false\n"
17611 "FROM (VALUES ");
17613 }
17614 else
17621 /* The ALTER ... DROP COLUMN commands must come after */
17626 }
17627 }
17629 {
17631 "WHERE attrelid = ");
17634 " AND attname = v.dname;\n");
17635 /* Now we can issue the actual DROP COLUMN commands */
17637 }
17638
17639 /*
17640 * Fix up inherited columns. As above, do the pg_attribute
17641 * manipulations in a single SQL command.
17642 */
17645 {
17648 {
17650 {
17653 "SET attislocal = false\n"
17654 "WHERE attrelid = ");
17657 " AND attname IN (");
17659 }
17660 else
17663 }
17664 }
17667
17668 /*
17669 * Fix up not-null constraints that come from inheritance. As
17670 * above, do the pg_constraint manipulations in a single SQL
17671 * command. (Actually, two in special cases, if we're doing an
17672 * upgrade from < 18).
17673 */
17676 resetPQExpBuffer(extra);
17678 {
17679 /*
17680 * If a not-null constraint comes from inheritance, reset
17681 * conislocal. The inhcount is fixed by ALTER TABLE INHERIT,
17682 * below. Special hack: in versions < 18, columns with no
17683 * local definition need their constraint to be matched by
17684 * column number in conkeys instead of by constraint name,
17685 * because the latter is not available. (We distinguish the
17686 * case because the constraint name is the empty string.)
17687 */
17690 {
17692 {
17694 {
17696 "SET conislocal = false\n"
17697 "WHERE contype = 'n' AND conrelid = ");
17700 "conname IN (");
17702 }
17703 else
17706 }
17707 else
17708 {
17710 {
17712 "SET conislocal = false\n"
17713 "WHERE contype = 'n' AND conrelid = ");
17716 "conkey IN (");
17718 }
17719 else
17722 }
17723 }
17724 }
17729
17732
17733 /*
17734 * Add inherited CHECK constraints, if any.
17735 *
17736 * For partitions, they were already dumped, and conislocal
17737 * doesn't need fixing.
17738 *
17739 * As above, issue only one direct manipulation of pg_constraint.
17740 * Although it is tempting to merge the ALTER ADD CONSTRAINT
17741 * commands into one as well, refrain for now due to concern about
17742 * possible backend memory bloat if there are many such
17743 * constraints.
17744 */
17745 resetPQExpBuffer(extra);
17748 {
17750
17752 continue;
17753
17759 constr->condef);
17760 /* Update pg_constraint after all the ALTER TABLEs */
17762 {
17764 "SET conislocal = false\n"
17765 "WHERE contype = 'c' AND conrelid = ");
17770 }
17771 else
17774 }
17776 {
17779 }
17780
17782 {
17784 for (k = 0; k < numParents; k++)
17785 {
17787
17789 qualrelname,
17791 }
17792 }
17793
17795 {
17798 qualrelname,
17800 zeroIsError));
17801 }
17802 }
17803
17804 /*
17805 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
17806 * relminmxid of all vacuumable relations. (While vacuum.c processes
17807 * TOAST tables semi-independently, here we see them only as children
17808 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
17809 * child toast table is handled below.)
17810 */
17814 {
17817 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17818 "WHERE oid = ",
17822
17824 {
17825 /*
17826 * The toast table will have the same OID at restore, so we
17827 * can safely target it by OID.
17828 */
17829 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
17831 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17832 "WHERE oid = '%u';\n",
17833 tbinfo->toast_frozenxid,
17835 }
17836 }
17837
17838 /*
17839 * In binary_upgrade mode, restore matviews' populated status by
17840 * poking pg_class directly. This is pretty ugly, but we can't use
17841 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
17842 * matview is not populated even though this matview is; in any case,
17843 * we want to transfer the matview's heap storage, not run REFRESH.
17844 */
17846 tbinfo->relispopulated)
17847 {
17850 "SET relispopulated = 't'\n"
17851 "WHERE oid = ");
17854 }
17855
17856 /*
17857 * Dump additional per-column properties that we can't handle in the
17858 * main CREATE TABLE command.
17859 */
17861 {
17862 /* None of this applies to dropped columns */
17864 continue;
17865
17866 /*
17867 * Dump per-column statistics information. We only issue an ALTER
17868 * TABLE statement if the attstattarget entry for this column is
17869 * not the default value.
17870 */
17876
17877 /*
17878 * Dump per-column storage information. The statement is only
17879 * dumped if the storage has been changed from the type's default.
17880 */
17882 {
17884 {
17887 break;
17890 break;
17893 break;
17896 break;
17897 default:
17899 }
17900
17901 /*
17902 * Only dump the statement if it's a storage type we recognize
17903 */
17908 storage);
17909 }
17910
17911 /*
17912 * Dump per-column compression, if it's been set.
17913 */
17915 {
17917
17919 {
17920 case 'p':
17922 break;
17923 case 'l':
17925 break;
17926 default:
17928 break;
17929 }
17930
17935 cmname);
17936 }
17937
17938 /*
17939 * Dump per-column attributes.
17940 */
17946
17947 /*
17948 * Dump per-column fdw options.
17949 */
17952 appendPQExpBuffer(q,
17953 "ALTER FOREIGN TABLE ONLY %s ALTER COLUMN %s OPTIONS (\n"
17954 " %s\n"
17955 ");\n",
17956 qualrelname,
17959 } /* end loop over columns */
17960
17964 }
17965
17966 /*
17967 * dump properties we only have ALTER TABLE syntax for
17968 */
17973 {
17975 {
17976 /* nothing to do, will be set when the index is dumped */
17977 }
17979 {
17981 qualrelname);
17982 }
17984 {
17986 qualrelname);
17987 }
17988 }
17989
17992 qualrelname);
17993
17997 tbinfo->dobj.namespace->dobj.name);
17998
18000 {
18003
18004 /*
18005 * _selectTablespace() relies on tablespace-enabled objects in the
18006 * default tablespace to have a tablespace of "" (empty string) versus
18007 * non-tablespace-enabled objects to have a tablespace of NULL.
18008 * getTables() sets tbinfo->reltablespace to "" for the default
18009 * tablespace (not NULL).
18010 */
18013
18016 tableam = tbinfo->amname;
18017
18020 .namespace = tbinfo->dobj.namespace->dobj.name,
18021 .tablespace = tablespace,
18022 .tableam = tableam,
18023 .relkind = tbinfo->relkind,
18024 .owner = tbinfo->rolname,
18025 .description = reltypename,
18026 .section = tbinfo->postponed_def ?
18028 .createStmt = q->data,
18030 }
18031
18032 /* Dump Table Comments */
18035
18036 /* Dump Table Security Labels */
18039
18040 /*
18041 * Dump comments for not-null constraints that aren't to be dumped
18042 * separately (those are processed by collectComments/dumpComment).
18043 */
18045 fout->remoteVersion >= 180000)
18046 {
18049
18051 {
18054 {
18056 {
18058 tag = createPQExpBuffer();
18059 }
18060 else
18061 {
18063 resetPQExpBuffer(tag);
18064 }
18065
18070
18073
18076 .namespace = tbinfo->dobj.namespace->dobj.name,
18077 .owner = tbinfo->rolname,
18078 .description = "COMMENT",
18079 .section = SECTION_NONE,
18080 .createStmt = comment->data,
18081 .deps = &(tbinfo->dobj.dumpId),
18082 .nDeps = 1));
18083 }
18084 }
18085
18087 destroyPQExpBuffer(tag);
18088 }
18089
18090 /* Dump comments on inlined table constraints */
18092 {
18094
18096 continue;
18097
18100 }
18101
18102 destroyPQExpBuffer(q);
18104 destroyPQExpBuffer(extra);
18107}
References append_depends_on_extension(), appendBinaryPQExpBuffer(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendReloptionsArrayAH(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), Assert, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel(), comment, _constraintInfo::condef, _constraintInfo::conislocal, createDummyViewAsClause(), createDumpId(), createPQExpBuffer(), createViewAsClause(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, _dumpOptions::dumpSchema, dumpTableComment(), dumpTableConstraintComment(), dumpTableSecLabel(), ExecuteSqlQueryForSingleRow(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, free, getFormattedTypeName(), j, PQExpBufferData::len, _dumpableObject::name, nilCatalogId, _dumpOptions::no_toast_compression, nonemptyReloptions(), OidIsValid, _tableInfo::parents, pg_log_warning, pg_strdup(), PQclear, PQfnumber(), PQgetvalue, resetPQExpBuffer(), SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, _constraintInfo::separate, shouldPrintColumn(), storage, tablespace, and zeroIsError.
Referenced by dumpTable().
◆ dumpTableSecLabel()
|
static |
Definition at line 16634 of file pg_dump.c.
16635{
16640 PQExpBuffer query;
16641 PQExpBuffer target;
16642
16643 /* do nothing, if --no-security-labels is supplied */
16645 return;
16646
16647 /* SecLabel are SCHEMA not data */
16649 return;
16650
16651 /* Search for comments associated with relation, using table */
16653 tbinfo->dobj.catId.oid,
16654 &labels);
16655
16656 /* If security labels exist, build SECURITY LABEL statements */
16658 return;
16659
16660 query = createPQExpBuffer();
16661 target = createPQExpBuffer();
16662
16664 {
16665 const char *colname;
16669
16670 resetPQExpBuffer(target);
16671 if (objsubid == 0)
16672 {
16675 }
16676 else
16677 {
16679 /* first fmtXXX result must be consumed before calling again */
16683 }
16688 }
16690 {
16691 resetPQExpBuffer(target);
16696 .namespace = tbinfo->dobj.namespace->dobj.name,
16697 .owner = tbinfo->rolname,
16698 .description = "SECURITY LABEL",
16699 .section = SECTION_NONE,
16700 .createStmt = query->data,
16701 .deps = &(tbinfo->dobj.dumpId),
16702 .nDeps = 1));
16703 }
16704 destroyPQExpBuffer(query);
16705 destroyPQExpBuffer(target);
16706}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpSchema, fb(), findSecLabels(), fmtId(), fmtQualifiedDumpable, getAttrName(), i, label, PQExpBufferData::len, nilCatalogId, _dumpOptions::no_security_labels, resetPQExpBuffer(), and SECTION_NONE.
Referenced by dumpTableSchema().
◆ dumpTransform()
|
static |
Definition at line 13994 of file pg_dump.c.
13995{
14005
14006 /* Do nothing if not dumping schema */
14008 return;
14009
14010 /* Cannot dump if we don't have the transform functions' info */
14012 {
14016 transform->trffromsql);
14017 }
14019 {
14023 transform->trftosql);
14024 }
14025
14030
14033
14036
14039
14041 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
14042
14044 {
14046 {
14048
14049 /*
14050 * Always qualify the function name (format_function_signature
14051 * won't qualify it).
14052 */
14056 }
14057 else
14059 }
14060
14062 {
14065
14067 {
14069
14070 /*
14071 * Always qualify the function name (format_function_signature
14072 * won't qualify it).
14073 */
14077 }
14078 else
14080 }
14081
14083
14086
14089
14093
14097 .description = "TRANSFORM",
14098 .section = SECTION_PRE_DATA,
14099 .createStmt = defqry->data,
14100 .dropStmt = delqry->data,
14103
14104 /* Dump Transform Comments */
14109
14115}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), _dumpableObject::dependencies, destroyPQExpBuffer(), _transformInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, _dumpOptions::dumpSchema, fb(), findFuncByOid(), fmtId(), format_function_signature(), free, get_language_name(), getFormattedTypeName(), _dumpableObject::nDeps, OidIsValid, pg_fatal, pg_log_warning, SECTION_PRE_DATA, _transformInfo::trffromsql, _transformInfo::trflang, _transformInfo::trftosql, _transformInfo::trftype, and zeroAsNone.
Referenced by dumpDumpableObject().
◆ dumpTrigger()
|
static |
Definition at line 19537 of file pg_dump.c.
19538{
19541 PQExpBuffer query;
19546 char *tag;
19547
19548 /* Do nothing if not dumping schema */
19550 return;
19551
19552 query = createPQExpBuffer();
19556
19558
19561
19564
19565 /* Triggers can depend on extensions */
19567 "pg_catalog.pg_trigger", "TRIGGER",
19568 trigidentity->data);
19569
19571 {
19573
19574 /*
19575 * Partition triggers only appear here because their 'tgenabled' flag
19576 * differs from its parent's. The trigger is created already, so
19577 * remove the CREATE and replace it with an ALTER. (Clear out the
19578 * DROP query too, so that pg_dump --create does not cause errors.)
19579 */
19580 resetPQExpBuffer(query);
19586 {
19587 case 'f':
19588 case 'D':
19590 break;
19591 case 't':
19592 case 'O':
19594 break;
19595 case 'R':
19597 break;
19598 case 'A':
19600 break;
19601 }
19604 }
19606 {
19611 {
19612 case 'D':
19613 case 'f':
19615 break;
19616 case 'A':
19618 break;
19619 case 'R':
19621 break;
19622 default:
19624 break;
19625 }
19628 }
19629
19632
19634
19637 ARCHIVE_OPTS(.tag = tag,
19639 .owner = tbinfo->rolname,
19640 .description = "TRIGGER",
19641 .section = SECTION_POST_DATA,
19642 .createStmt = query->data,
19643 .dropStmt = delqry->data));
19644
19649
19650 free(tag);
19651 destroyPQExpBuffer(query);
19656}
References append_depends_on_extension(), appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, pg_strdup(), psprintf(), resetPQExpBuffer(), and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ dumpTSConfig()
|
static |
Definition at line 15950 of file pg_dump.c.
15951{
15953 PQExpBuffer q;
15955 PQExpBuffer query;
15957 PGresult *res;
15958 char *nspname;
15960 int ntups,
15961 i;
15964
15965 /* Do nothing if not dumping schema */
15967 return;
15968
15969 q = createPQExpBuffer();
15971 query = createPQExpBuffer();
15972
15974
15975 /* Fetch name and namespace of the config's parser */
15977 "FROM pg_ts_parser p, pg_namespace n "
15978 "WHERE p.oid = '%u' AND n.oid = prsnamespace",
15979 cfginfo->cfgparser);
15981 nspname = PQgetvalue(res, 0, 0);
15983
15986
15989
15990 PQclear(res);
15991
15992 resetPQExpBuffer(query);
15993 appendPQExpBuffer(query,
15994 "SELECT\n"
15995 " ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t\n"
15996 " WHERE t.tokid = m.maptokentype ) AS tokenname,\n"
15997 " m.mapdict::pg_catalog.regdictionary AS dictname\n"
15998 "FROM pg_catalog.pg_ts_config_map AS m\n"
15999 "WHERE m.mapcfg = '%u'\n"
16000 "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
16002
16004 ntups = PQntuples(res);
16005
16008
16010 {
16013
16016 {
16017 /* starting a new token type, so start a new command */
16022 /* tokenname needs quoting, dictname does NOT */
16025 }
16026 else
16028 }
16029
16030 if (ntups > 0)
16032
16033 PQclear(res);
16034
16037
16041 cfginfo->dobj.namespace->dobj.name);
16042
16046 .namespace = cfginfo->dobj.namespace->dobj.name,
16047 .owner = cfginfo->rolname,
16048 .description = "TEXT SEARCH CONFIGURATION",
16049 .section = SECTION_PRE_DATA,
16050 .createStmt = q->data,
16051 .dropStmt = delq->data));
16052
16053 /* Dump Configuration Comments */
16058
16059 destroyPQExpBuffer(q);
16061 destroyPQExpBuffer(query);
16063}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, i, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, resetPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpTSDictionary()
|
static |
Definition at line 15812 of file pg_dump.c.
15813{
15815 PQExpBuffer q;
15817 PQExpBuffer query;
15819 PGresult *res;
15820 char *nspname;
15822
15823 /* Do nothing if not dumping schema */
15825 return;
15826
15827 q = createPQExpBuffer();
15829 query = createPQExpBuffer();
15830
15832
15833 /* Fetch name and namespace of the dictionary's template */
15835 "FROM pg_ts_template p, pg_namespace n "
15836 "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
15837 dictinfo->dicttemplate);
15839 nspname = PQgetvalue(res, 0, 0);
15841
15844
15848
15849 PQclear(res);
15850
15851 /* the dictinitoption can be dumped straight into the command */
15854
15856
15859
15863 dictinfo->dobj.namespace->dobj.name);
15864
15868 .namespace = dictinfo->dobj.namespace->dobj.name,
15869 .owner = dictinfo->rolname,
15870 .description = "TEXT SEARCH DICTIONARY",
15871 .section = SECTION_PRE_DATA,
15872 .createStmt = q->data,
15873 .dropStmt = delq->data));
15874
15875 /* Dump Dictionary Comments */
15880
15881 destroyPQExpBuffer(q);
15883 destroyPQExpBuffer(query);
15885}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, ExecuteSqlQueryForSingleRow(), fb(), fmtId(), fmtQualifiedDumpable, free, pg_strdup(), PQclear, PQgetvalue, and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpTSParser()
|
static |
Definition at line 15748 of file pg_dump.c.
15749{
15751 PQExpBuffer q;
15754
15755 /* Do nothing if not dumping schema */
15757 return;
15758
15759 q = createPQExpBuffer();
15761
15763
15766
15778
15781
15785 prsinfo->dobj.namespace->dobj.name);
15786
15790 .namespace = prsinfo->dobj.namespace->dobj.name,
15791 .description = "TEXT SEARCH PARSER",
15792 .section = SECTION_PRE_DATA,
15793 .createStmt = q->data,
15794 .dropStmt = delq->data));
15795
15796 /* Dump Parser Comments */
15801
15802 destroyPQExpBuffer(q);
15805}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), convertTSFunction(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, InvalidOid, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpTSTemplate()
|
static |
Definition at line 15892 of file pg_dump.c.
15893{
15895 PQExpBuffer q;
15898
15899 /* Do nothing if not dumping schema */
15901 return;
15902
15903 q = createPQExpBuffer();
15905
15907
15910
15916
15919
15923 tmplinfo->dobj.namespace->dobj.name);
15924
15928 .namespace = tmplinfo->dobj.namespace->dobj.name,
15929 .description = "TEXT SEARCH TEMPLATE",
15930 .section = SECTION_PRE_DATA,
15931 .createStmt = q->data,
15932 .dropStmt = delq->data));
15933
15934 /* Dump Template Comments */
15939
15940 destroyPQExpBuffer(q);
15943}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), convertTSFunction(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, free, InvalidOid, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpType()
Definition at line 12075 of file pg_dump.c.
12076{
12078
12079 /* Do nothing if not dumping schema */
12081 return;
12082
12083 /* Dump out in proper style */
12096 else
12098 tyinfo->dobj.name);
12099}
References dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), _dumpOptions::dumpSchema, dumpUndefinedType(), fb(), and pg_log_warning.
Referenced by crashDumpHandler(), and dumpDumpableObject().
◆ dumpUndefinedType()
Definition at line 12404 of file pg_dump.c.
12405{
12411
12414
12416
12419 tyinfo->dobj.catId.oid,
12420 false, false);
12421
12423 qualtypname);
12424
12428 tyinfo->dobj.namespace->dobj.name);
12429
12433 .namespace = tyinfo->dobj.namespace->dobj.name,
12434 .owner = tyinfo->rolname,
12435 .description = "TYPE",
12436 .section = SECTION_PRE_DATA,
12437 .createStmt = q->data,
12438 .dropStmt = delq->data));
12439
12440 /* Dump Type Comments and Security Labels */
12445
12450
12454 tyinfo->dobj.namespace->dobj.name,
12456
12457 destroyPQExpBuffer(q);
12461}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), fb(), fmtId(), fmtQualifiedDumpable, free, InvalidDumpId, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpType().
◆ dumpUserMappings()
|
static |
Definition at line 16240 of file pg_dump.c.
16244{
16245 PQExpBuffer q;
16247 PQExpBuffer query;
16248 PQExpBuffer tag;
16249 PGresult *res;
16250 int ntups;
16254
16255 q = createPQExpBuffer();
16256 tag = createPQExpBuffer();
16258 query = createPQExpBuffer();
16259
16260 /*
16261 * We read from the publicly accessible view pg_user_mappings, so as not
16262 * to fail if run by a non-superuser. Note that the view will show
16263 * umoptions as null if the user hasn't got privileges for the associated
16264 * server; this means that pg_dump will dump such a mapping, but with no
16265 * OPTIONS clause. A possible alternative is to skip such mappings
16266 * altogether, but it's not clear that that's an improvement.
16267 */
16268 appendPQExpBuffer(query,
16269 "SELECT usename, "
16270 "array_to_string(ARRAY("
16271 "SELECT quote_ident(option_name) || ' ' || "
16272 "quote_literal(option_value) "
16273 "FROM pg_options_to_table(umoptions) "
16274 "ORDER BY option_name"
16275 "), E',\n ') AS umoptions "
16276 "FROM pg_user_mappings "
16277 "WHERE srvid = '%u' "
16278 "ORDER BY usename",
16279 catalogId.oid);
16280
16282
16283 ntups = PQntuples(res);
16286
16288 {
16291
16294
16295 resetPQExpBuffer(q);
16298
16301
16303
16307
16308 resetPQExpBuffer(tag);
16310 usename, servername);
16311
16314 .namespace = namespace,
16315 .owner = owner,
16316 .description = "USER MAPPING",
16317 .section = SECTION_PRE_DATA,
16318 .createStmt = q->data,
16319 .dropStmt = delq->data));
16320 }
16321
16322 PQclear(res);
16323
16324 destroyPQExpBuffer(query);
16326 destroyPQExpBuffer(tag);
16327 destroyPQExpBuffer(q);
16328}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), fmtId(), i, nilCatalogId, CatalogId::oid, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, resetPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpForeignServer().
◆ expand_extension_name_patterns()
|
static |
Definition at line 1736 of file pg_dump.c.
1740{
1741 PQExpBuffer query;
1742 PGresult *res;
1743 SimpleStringListCell *cell;
1745
1747 return; /* nothing to do */
1748
1749 query = createPQExpBuffer();
1750
1751 /*
1752 * The loop below runs multiple SELECTs might sometimes result in
1753 * duplicate entries in the OID list, but we don't care.
1754 */
1756 {
1758
1759 appendPQExpBufferStr(query,
1760 "SELECT oid FROM pg_catalog.pg_extension e\n");
1763 &dotcnt);
1766 cell->val);
1767
1771
1773 {
1775 }
1776
1777 PQclear(res);
1778 resetPQExpBuffer(query);
1779 }
1780
1781 destroyPQExpBuffer(query);
1782}
References appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), GetConnection(), i, SimpleStringListCell::next, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, processSQLNamePattern(), resetPQExpBuffer(), simple_oid_list_append(), strict_names, and SimpleStringListCell::val.
Referenced by main().
◆ expand_foreign_server_name_patterns()
|
static |
Definition at line 1789 of file pg_dump.c.
1792{
1793 PQExpBuffer query;
1794 PGresult *res;
1795 SimpleStringListCell *cell;
1797
1799 return; /* nothing to do */
1800
1801 query = createPQExpBuffer();
1802
1803 /*
1804 * The loop below runs multiple SELECTs might sometimes result in
1805 * duplicate entries in the OID list, but we don't care.
1806 */
1807
1809 {
1811
1812 appendPQExpBufferStr(query,
1813 "SELECT oid FROM pg_catalog.pg_foreign_server s\n");
1816 &dotcnt);
1819 cell->val);
1820
1824
1827
1828 PQclear(res);
1829 resetPQExpBuffer(query);
1830 }
1831
1832 destroyPQExpBuffer(query);
1833}
References appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), GetConnection(), i, SimpleStringListCell::next, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, processSQLNamePattern(), resetPQExpBuffer(), simple_oid_list_append(), and SimpleStringListCell::val.
Referenced by main().
◆ expand_schema_name_patterns()
|
static |
Definition at line 1677 of file pg_dump.c.
1681{
1682 PQExpBuffer query;
1683 PGresult *res;
1684 SimpleStringListCell *cell;
1686
1688 return; /* nothing to do */
1689
1690 query = createPQExpBuffer();
1691
1692 /*
1693 * The loop below runs multiple SELECTs might sometimes result in
1694 * duplicate entries in the OID list, but we don't care.
1695 */
1696
1698 {
1701
1702 appendPQExpBufferStr(query,
1703 "SELECT oid FROM pg_catalog.pg_namespace n\n");
1707 &dotcnt);
1710 cell->val);
1714
1718
1720 {
1722 }
1723
1724 PQclear(res);
1725 resetPQExpBuffer(query);
1726 }
1727
1728 destroyPQExpBuffer(query);
1729}
References appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), GetConnection(), i, initPQExpBuffer(), SimpleStringListCell::next, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, processSQLNamePattern(), prohibit_crossdb_refs(), resetPQExpBuffer(), simple_oid_list_append(), strict_names, termPQExpBuffer(), and SimpleStringListCell::val.
Referenced by main().
◆ expand_table_name_patterns()
|
static |
Definition at line 1841 of file pg_dump.c.
1844{
1845 PQExpBuffer query;
1846 PGresult *res;
1847 SimpleStringListCell *cell;
1849
1851 return; /* nothing to do */
1852
1853 query = createPQExpBuffer();
1854
1855 /*
1856 * this might sometimes result in duplicate entries in the OID list, but
1857 * we don't care.
1858 */
1859
1861 {
1864
1865 /*
1866 * Query must remain ABSOLUTELY devoid of unqualified names. This
1867 * would be unnecessary given a pg_table_is_visible() variant taking a
1868 * search_path argument.
1869 *
1870 * For with_child_tables, we start with the basic query's results and
1871 * recursively search the inheritance tree to add child tables.
1872 */
1874 {
1876 }
1877
1878 appendPQExpBuffer(query,
1879 "SELECT c.oid"
1880 "\nFROM pg_catalog.pg_class c"
1881 "\n LEFT JOIN pg_catalog.pg_namespace n"
1882 "\n ON n.oid OPERATOR(pg_catalog.=) c.relnamespace"
1883 "\nWHERE c.relkind OPERATOR(pg_catalog.=) ANY"
1884 "\n (array['%c', '%c', '%c', '%c', '%c', '%c'])\n",
1887 RELKIND_PARTITIONED_TABLE);
1892 &dotcnt);
1895 cell->val);
1899
1901 {
1903 "\nSELECT i.inhrelid"
1904 "\nFROM partition_tree p"
1905 "\n JOIN pg_catalog.pg_inherits i"
1906 "\n ON p.relid OPERATOR(pg_catalog.=) i.inhparent"
1907 "\n)"
1908 "\nSELECT relid FROM partition_tree");
1909 }
1910
1914 ALWAYS_SECURE_SEARCH_PATH_SQL));
1917
1919 {
1921 }
1922
1923 PQclear(res);
1924 resetPQExpBuffer(query);
1925 }
1926
1927 destroyPQExpBuffer(query);
1928}
References ALWAYS_SECURE_SEARCH_PATH_SQL, appendPQExpBuffer(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), GetConnection(), i, initPQExpBuffer(), SimpleStringListCell::next, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, processSQLNamePattern(), prohibit_crossdb_refs(), resetPQExpBuffer(), simple_oid_list_append(), strict_names, termPQExpBuffer(), and SimpleStringListCell::val.
Referenced by main().
◆ fetchAttributeStats()
Definition at line 11031 of file pg_dump.c.
11032{
11036 int count = 0;
11041
11042 /*
11043 * Our query for retrieving statistics for multiple relations uses WITH
11044 * ORDINALITY and multi-argument UNNEST(), both of which were introduced
11045 * in v9.4. For older versions, we resort to gathering statistics for a
11046 * single relation at a time.
11047 */
11049 max_rels = 1;
11050
11051 /* If we're just starting, set our TOC pointer. */
11052 if (!te)
11054
11055 /*
11056 * We can't easily avoid a second TOC scan for the tar format because it
11057 * writes restore.sql separately, which means we must execute the queries
11058 * twice. This feels risky, but there is no known reason it should
11059 * generate different output than the first pass. Even if it does, the
11060 * worst-case scenario is that restore.sql might have different statistics
11061 * data than the archive.
11062 */
11064 {
11067 }
11068
11071
11072 /*
11073 * Scan the TOC for the next set of relevant stats entries. We assume
11074 * that statistics are dumped in the order they are listed in the TOC.
11075 * This is perhaps not the sturdiest assumption, so we verify it matches
11076 * reality in dumpRelationStats_dumper().
11077 */
11079 {
11082 {
11085 count++;
11086 }
11087 }
11088
11091
11092 /* Execute the query for the next batch of relations. */
11093 if (count > 0)
11094 {
11096
11103 destroyPQExpBuffer(query);
11104 }
11105
11108 return res;
11109}
References appendPGArray(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, archTar, createPQExpBuffer(), PQExpBufferData::data, _tocEntry::desc, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), _archiveHandle::format, MAX_ATTR_STATS_RELS, _tocEntry::next, PGRES_TUPLES_OK, REQ_STATS, _tocEntry::reqs, _tocEntry::tag, and _archiveHandle::toc.
Referenced by dumpRelationStats_dumper().
◆ findComments()
|
static |
Definition at line 11516 of file pg_dump.c.
11517{
11519 CommentItem *low;
11520 CommentItem *high;
11521 int nmatch;
11522
11523 /*
11524 * Do binary search to find some item matching the object.
11525 */
11526 low = &comments[0];
11528 while (low <= high)
11529 {
11530 middle = low + (high - low) / 2;
11531
11533 high = middle - 1;
11535 low = middle + 1;
11537 high = middle - 1;
11539 low = middle + 1;
11540 else
11541 break; /* found a match */
11542 }
11543
11544 if (low > high) /* no matches */
11545 {
11547 return 0;
11548 }
11549
11550 /*
11551 * Now determine how many items match the object. The search loop
11552 * invariant still holds: only items between low and high inclusive could
11553 * match.
11554 */
11555 nmatch = 1;
11557 {
11559 objoid != middle[-1].objoid)
11560 break;
11561 middle--;
11562 nmatch++;
11563 }
11564
11566
11567 middle += nmatch;
11569 {
11571 objoid != middle->objoid)
11572 break;
11573 middle++;
11574 nmatch++;
11575 }
11576
11577 return nmatch;
11578}
References comments, fb(), items, and ncomments.
Referenced by dumpCommentExtended(), dumpCompositeTypeColComments(), and dumpTableComment().
◆ findDumpableDependencies()
|
static |
Definition at line 20545 of file pg_dump.c.
20547{
20549
20550 /*
20551 * Ignore section boundary objects: if we search through them, we'll
20552 * report lots of bogus dependencies.
20553 */
20556 return;
20557
20559 {
20561
20563 {
20564 /* Object will be dumped, so just reference it as a dependency */
20565 if (*nDeps >= *allocDeps)
20566 {
20567 *allocDeps *= 2;
20570 }
20571 (*dependencies)[*nDeps] = depid;
20572 (*nDeps)++;
20573 }
20574 else
20575 {
20576 /*
20577 * Object will not be dumped, so recursively consider its deps. We
20578 * rely on the assumption that sortDumpableObjects already broke
20579 * any dependency loops, else we might recurse infinitely.
20580 */
20582
20585 dependencies, nDeps, allocDeps);
20586 }
20587 }
20588}
References _dumpableObject::dependencies, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, fb(), findDumpableDependencies(), findObjectByDumpId(), i, _dumpableObject::nDeps, _dumpableObject::objType, pg_realloc(), and TocIDRequired().
Referenced by BuildArchiveDependencies(), and findDumpableDependencies().
◆ findNamespace()
|
static |
Definition at line 6119 of file pg_dump.c.
6120{
6122
6127}
References fb(), findNamespaceByOid(), and pg_fatal.
Referenced by getAggregates(), getCollations(), getConversions(), getDefaultACLs(), getExtendedStatistics(), getFuncs(), getOpclasses(), getOperators(), getOpfamilies(), getTables(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), and getTypes().
◆ findSecLabels()
|
static |
Definition at line 16716 of file pg_dump.c.
16717{
16719 SecLabelItem *low;
16720 SecLabelItem *high;
16721 int nmatch;
16722
16724 {
16726 return 0;
16727 }
16728
16729 /*
16730 * Do binary search to find some item matching the object.
16731 */
16732 low = &seclabels[0];
16734 while (low <= high)
16735 {
16736 middle = low + (high - low) / 2;
16737
16739 high = middle - 1;
16741 low = middle + 1;
16743 high = middle - 1;
16745 low = middle + 1;
16746 else
16747 break; /* found a match */
16748 }
16749
16750 if (low > high) /* no matches */
16751 {
16753 return 0;
16754 }
16755
16756 /*
16757 * Now determine how many items match the object. The search loop
16758 * invariant still holds: only items between low and high inclusive could
16759 * match.
16760 */
16761 nmatch = 1;
16763 {
16765 objoid != middle[-1].objoid)
16766 break;
16767 middle--;
16768 nmatch++;
16769 }
16770
16772
16773 middle += nmatch;
16775 {
16777 objoid != middle->objoid)
16778 break;
16779 middle++;
16780 nmatch++;
16781 }
16782
16783 return nmatch;
16784}
References fb(), items, nseclabels, and seclabels.
Referenced by dumpSecLabel(), and dumpTableSecLabel().
◆ fmtCopyColumnList()
Definition at line 20652 of file pg_dump.c.
20653{
20660
20664 {
20666 continue;
20668 continue;
20673 }
20674
20676 return ""; /* no undropped columns */
20677
20680}
References appendPQExpBufferChar(), appendPQExpBufferStr(), PQExpBufferData::data, fb(), fmtId(), and i.
Referenced by dumpTableData(), and dumpTableData_copy().
◆ forcePartitionRootLoad()
Definition at line 2856 of file pg_dump.c.
2857{
2859
2862
2865 return true;
2867 {
2871 return true;
2872 }
2873
2874 return false;
2875}
Referenced by dumpTableData(), and dumpTableData_insert().
◆ format_aggregate_signature()
|
static |
Definition at line 15356 of file pg_dump.c.
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), buf, fb(), fmtId(), getFormattedTypeName(), initPQExpBuffer(), j, and zeroIsError.
Referenced by dumpAgg().
◆ format_function_arguments()
|
static |
Definition at line 13415 of file pg_dump.c.
13416{
13418
13423 else
13426}
References appendPQExpBuffer(), appendPQExpBufferStr(), _funcInfo::dobj, fb(), fmtId(), fn(), initPQExpBuffer(), _dumpableObject::name, and _funcInfo::nargs.
Referenced by dumpAgg(), and dumpFunc().
◆ format_function_signature()
|
static |
Definition at line 13438 of file pg_dump.c.
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _funcInfo::argtypes, _funcInfo::dobj, fb(), fmtId(), fn(), getFormattedTypeName(), initPQExpBuffer(), j, _dumpableObject::name, _funcInfo::nargs, and zeroIsError.
Referenced by dumpAgg(), dumpCast(), dumpFunc(), and dumpTransform().
◆ get_language_name()
Definition at line 9146 of file pg_dump.c.
9147{
9148 PQExpBuffer query;
9149 PGresult *res;
9151
9152 query = createPQExpBuffer();
9156 destroyPQExpBuffer(query);
9157 PQclear(res);
9158
9160}
References appendPQExpBuffer(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), fmtId(), pg_strdup(), PQclear, and PQgetvalue.
Referenced by dumpTransform(), and getTransforms().
◆ get_next_possible_free_pg_type_oid()
|
static |
Definition at line 5695 of file pg_dump.c.
5696{
5697 /*
5698 * If the old version didn't assign an array type, but the new version
5699 * does, we must select an unused type OID to assign. This currently only
5700 * happens for domains, when upgrading pre-v11 to v11 and up.
5701 *
5702 * Note: local state here is kind of ugly, but we must have some, since we
5703 * mustn't choose the same unused OID more than once.
5704 */
5706 PGresult *res;
5708
5709 do
5710 {
5711 ++next_possible_free_oid;
5713 "SELECT EXISTS(SELECT 1 "
5714 "FROM pg_catalog.pg_type "
5715 "WHERE oid = '%u'::pg_catalog.oid);",
5716 next_possible_free_oid);
5719 PQclear(res);
5721
5723}
References ExecuteSqlQueryForSingleRow(), fb(), FirstNormalObjectId, PQclear, PQgetvalue, and printfPQExpBuffer().
Referenced by binary_upgrade_set_type_oids_by_type_oid().
◆ get_synchronized_snapshot()
Definition at line 1625 of file pg_dump.c.
1626{
1627 char *query = "SELECT pg_catalog.pg_export_snapshot()";
1628 char *result;
1629 PGresult *res;
1630
1633 PQclear(res);
1634
1635 return result;
1636}
References ExecuteSqlQueryForSingleRow(), fb(), pg_strdup(), PQclear, and PQgetvalue.
Referenced by setup_connection().
◆ getAccessMethods()
Definition at line 6584 of file pg_dump.c.
6585{
6586 PGresult *res;
6587 int ntups;
6589 PQExpBuffer query;
6596
6597 query = createPQExpBuffer();
6598
6599 /*
6600 * Select all access methods from pg_am table. v9.6 introduced CREATE
6601 * ACCESS METHOD, so earlier versions usually have only built-in access
6602 * methods. v9.6 also changed the access method API, replacing dozens of
6603 * pg_am columns with amhandler. Even if a user created an access method
6604 * by "INSERT INTO pg_am", we have no way to translate pre-v9.6 pg_am
6605 * columns to a v9.6+ CREATE ACCESS METHOD. Hence, before v9.6, read
6606 * pg_am just to facilitate findAccessMethodByOid() providing the
6607 * OID-to-name mapping.
6608 */
6611 appendPQExpBufferStr(query,
6612 "amtype, "
6613 "amhandler::pg_catalog.regproc AS amhandler ");
6614 else
6615 appendPQExpBufferStr(query,
6616 "'i'::pg_catalog.\"char\" AS amtype, "
6617 "'-'::pg_catalog.regproc AS amhandler ");
6619
6621
6622 ntups = PQntuples(res);
6623
6625
6631
6633 {
6642
6643 /* Decide whether we want to dump it */
6645 }
6646
6647 PQclear(res);
6648
6649 destroyPQExpBuffer(query);
6650}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_ACCESS_METHOD, ExecuteSqlQuery(), fb(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableAccessMethod().
Referenced by getSchemaData().
◆ getAdditionalACLs()
Definition at line 10768 of file pg_dump.c.
10769{
10771 PGresult *res;
10772 int ntups,
10773 i;
10774
10775 /* Check for per-column ACLs */
10776 appendPQExpBufferStr(query,
10777 "SELECT DISTINCT attrelid FROM pg_attribute "
10778 "WHERE attacl IS NOT NULL");
10779
10781
10782 ntups = PQntuples(res);
10784 {
10786 TableInfo *tblinfo;
10787
10788 tblinfo = findTableByOid(relid);
10789 /* OK to ignore tables we haven't got a DumpableObject for */
10790 if (tblinfo)
10791 {
10794 }
10795 }
10796 PQclear(res);
10797
10798 /* Fetch initial-privileges data */
10800 {
10801 printfPQExpBuffer(query,
10802 "SELECT objoid, classoid, objsubid, privtype, initprivs "
10803 "FROM pg_init_privs");
10804
10806
10807 ntups = PQntuples(res);
10809 {
10815 CatalogId objId;
10816 DumpableObject *dobj;
10817
10818 objId.tableoid = classoid;
10819 objId.oid = objoid;
10820 dobj = findObjectByCatalogId(objId);
10821 /* OK to ignore entries we haven't got a DumpableObject for */
10822 if (dobj)
10823 {
10824 /* Cope with sub-object initprivs */
10825 if (objsubid != 0)
10826 {
10828 {
10829 /* For a column initprivs, set the table's ACL flags */
10832 }
10833 else
10835 classoid, objoid, objsubid);
10836 continue;
10837 }
10838
10839 /*
10840 * We ignore any pg_init_privs.initprivs entry for the public
10841 * schema, as explained in getNamespaces().
10842 */
10845 continue;
10846
10847 /* Else it had better be of a type we think has ACLs */
10856 {
10858
10861 }
10862 else
10864 classoid, objoid, objsubid);
10865 }
10866 }
10867 PQclear(res);
10868 }
10869
10870 destroyPQExpBuffer(query);
10871}
References appendPQExpBufferStr(), atooid, _dumpableObject::components, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_AGG, DO_FDW, DO_FOREIGN_SERVER, DO_FUNC, DO_NAMESPACE, DO_PROCLANG, DO_TABLE, DO_TYPE, _tableInfo::dobj, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTableByOid(), _tableInfo::hascolumnACLs, i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_log_warning, PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, printfPQExpBuffer(), pstrdup(), and CatalogId::tableoid.
Referenced by main().
◆ getAggregates()
Definition at line 6786 of file pg_dump.c.
6787{
6789 PGresult *res;
6790 int ntups;
6803
6804 /*
6805 * Find all interesting aggregates. See comment in getFuncs() for the
6806 * rationale behind the filtering logic.
6807 */
6809 {
6811
6813 : "p.proisagg");
6814
6816 "p.proname AS aggname, "
6817 "p.pronamespace AS aggnamespace, "
6818 "p.pronargs, p.proargtypes, "
6819 "p.proowner, "
6820 "p.proacl AS aggacl, "
6821 "acldefault('f', p.proowner) AS acldefault "
6822 "FROM pg_proc p "
6823 "LEFT JOIN pg_init_privs pip ON "
6824 "(p.oid = pip.objoid "
6825 "AND pip.classoid = 'pg_proc'::regclass "
6826 "AND pip.objsubid = 0) "
6827 "WHERE %s AND ("
6828 "p.pronamespace != "
6829 "(SELECT oid FROM pg_namespace "
6830 "WHERE nspname = 'pg_catalog') OR "
6831 "p.proacl IS DISTINCT FROM pip.initprivs",
6832 agg_check);
6834 appendPQExpBufferStr(query,
6835 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6836 "classid = 'pg_proc'::regclass AND "
6837 "objid = p.oid AND "
6838 "refclassid = 'pg_extension'::regclass AND "
6839 "deptype = 'e')");
6841 }
6842 else
6843 {
6845 "pronamespace AS aggnamespace, "
6846 "pronargs, proargtypes, "
6847 "proowner, "
6848 "proacl AS aggacl, "
6849 "acldefault('f', proowner) AS acldefault "
6850 "FROM pg_proc p "
6851 "WHERE proisagg AND ("
6852 "pronamespace != "
6853 "(SELECT oid FROM pg_namespace "
6854 "WHERE nspname = 'pg_catalog')");
6856 appendPQExpBufferStr(query,
6857 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6858 "classid = 'pg_proc'::regclass AND "
6859 "objid = p.oid AND "
6860 "refclassid = 'pg_extension'::regclass AND "
6861 "deptype = 'e')");
6863 }
6864
6866
6867 ntups = PQntuples(res);
6868
6870
6880
6882 {
6900 else
6901 {
6906 }
6908
6909 /* Decide whether we want to dump it */
6911
6912 /* Mark whether aggregate has an ACL */
6915 }
6916
6917 PQclear(res);
6918
6919 destroyPQExpBuffer(query);
6920}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, _dumpOptions::binary_upgrade, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_AGG, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, InvalidOid, parseOidArray(), pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getAttrName()
Definition at line 18254 of file pg_dump.c.
18255{
18258 switch (attrnum)
18259 {
18261 return "ctid";
18263 return "xmin";
18265 return "cmin";
18267 return "xmax";
18269 return "cmax";
18271 return "tableoid";
18272 }
18274 attrnum, tblInfo->dobj.name);
18276}
References fb(), MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, pg_fatal, SelfItemPointerAttributeNumber, and TableOidAttributeNumber.
Referenced by dumpConstraint(), and dumpTableSecLabel().
◆ getCasts()
Definition at line 9057 of file pg_dump.c.
9058{
9059 PGresult *res;
9060 int ntups;
9071
9073 {
9075 "castsource, casttarget, castfunc, castcontext, "
9076 "castmethod "
9077 "FROM pg_cast c "
9078 "WHERE NOT EXISTS ( "
9079 "SELECT 1 FROM pg_range r "
9080 "WHERE c.castsource = r.rngtypid "
9081 "AND c.casttarget = r.rngmultitypid "
9082 ") "
9083 "ORDER BY 3,4");
9084 }
9085 else
9086 {
9088 "castsource, casttarget, castfunc, castcontext, "
9089 "castmethod "
9090 "FROM pg_cast ORDER BY 3,4");
9091 }
9092
9094
9095 ntups = PQntuples(res);
9096
9098
9106
9108 {
9112
9122
9123 /*
9124 * Try to name cast as concatenation of typnames. This is only used
9125 * for purposes of sorting. If we fail to find either type, the name
9126 * will be an empty string.
9127 */
9135
9136 /* Decide whether we want to dump it */
9138 }
9139
9140 PQclear(res);
9141
9142 destroyPQExpBuffer(query);
9143}
References appendPQExpBuffer(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_CAST, _typeInfo::dobj, ExecuteSqlQuery(), fb(), findTypeByOid(), i, initPQExpBuffer(), _dumpableObject::objType, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableCast().
Referenced by getSchemaData().
◆ getCollations()
Definition at line 6456 of file pg_dump.c.
6457{
6458 PGresult *res;
6459 int ntups;
6461 PQExpBuffer query;
6469
6470 query = createPQExpBuffer();
6471
6472 /*
6473 * find all collations, including builtin collations; we filter out
6474 * system-defined collations at dump-out time.
6475 */
6476
6478 "collnamespace, "
6479 "collowner, "
6480 "collencoding "
6481 "FROM pg_collation");
6482
6484
6485 ntups = PQntuples(res);
6486
6488
6495
6497 {
6507
6508 /* Decide whether we want to dump it */
6510 }
6511
6512 PQclear(res);
6513
6514 destroyPQExpBuffer(query);
6515}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_COLLATION, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getConstraints()
Definition at line 8308 of file pg_dump.c.
8309{
8312 PGresult *res;
8313 int ntups;
8318 i_conoid,
8319 i_conrelid,
8320 i_conname,
8321 i_confrelid,
8322 i_conindid,
8323 i_condef;
8324
8325 /*
8326 * We want to perform just one query against pg_constraint. However, we
8327 * mustn't try to select every row of the catalog and then sort it out on
8328 * the client side, because some of the server-side functions we need
8329 * would be unsafe to apply to tables we don't have lock on. Hence, we
8330 * build an array of the OIDs of tables we care about (and now have lock
8331 * on!), and use a WHERE clause to constrain which rows are selected.
8332 */
8335 {
8337
8339 continue;
8340
8341 /* OK, we need info for this table */
8345 }
8347
8348 appendPQExpBufferStr(query,
8349 "SELECT c.tableoid, c.oid, "
8350 "conrelid, conname, confrelid, ");
8353 else
8355 appendPQExpBuffer(query,
8356 "pg_catalog.pg_get_constraintdef(c.oid) AS condef\n"
8357 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8358 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
8359 "WHERE contype = 'f' ",
8360 tbloids->data);
8362 appendPQExpBufferStr(query,
8363 "AND conparentid = 0 ");
8364 appendPQExpBufferStr(query,
8365 "ORDER BY conrelid, conname");
8366
8368
8369 ntups = PQntuples(res);
8370
8378
8380
8381 curtblindx = -1;
8383 {
8386
8387 /*
8388 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8389 * order.
8390 */
8392 {
8394 {
8397 break;
8398 }
8401 }
8402
8419
8420 /*
8421 * Restoring an FK that points to a partitioned table requires that
8422 * all partition indexes have been attached beforehand. Ensure that
8423 * happens by making the constraint depend on each index partition
8424 * attach object.
8425 */
8428 {
8430
8432 {
8434 {
8436
8437 /* not our index? */
8439 continue;
8440
8443 break;
8444 }
8445 }
8446 }
8447 }
8448
8449 PQclear(res);
8450
8451 destroyPQExpBuffer(query);
8453}
References addConstrChildIdxDeps(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_FK_CONSTRAINT, DUMP_COMPONENT_DEFINITION, ExecuteSqlQuery(), fb(), findTableByOid(), i, InvalidOid, j, pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and tinfo.
Referenced by getSchemaData().
◆ getConversions()
Definition at line 6522 of file pg_dump.c.
6523{
6524 PGresult *res;
6525 int ntups;
6527 PQExpBuffer query;
6534
6535 query = createPQExpBuffer();
6536
6537 /*
6538 * find all conversions, including builtin conversions; we filter out
6539 * system-defined conversions at dump-out time.
6540 */
6541
6543 "connamespace, "
6544 "conowner "
6545 "FROM pg_conversion");
6546
6548
6549 ntups = PQntuples(res);
6550
6552
6558
6560 {
6569
6570 /* Decide whether we want to dump it */
6572 }
6573
6574 PQclear(res);
6575
6576 destroyPQExpBuffer(query);
6577}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_CONVERSION, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getDefaultACLs()
Definition at line 10600 of file pg_dump.c.
10601{
10604 PQExpBuffer query;
10605 PGresult *res;
10614 ntups;
10615
10616 query = createPQExpBuffer();
10617
10618 /*
10619 * Global entries (with defaclnamespace=0) replace the hard-wired default
10620 * ACL for their object type. We should dump them as deltas from the
10621 * default ACL, since that will be used as a starting point for
10622 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
10623 * non-global entries can only add privileges not revoke them. We must
10624 * dump those as-is (i.e., as deltas from an empty ACL).
10625 *
10626 * We can use defaclobjtype as the object type for acldefault(), except
10627 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
10628 * 's'.
10629 */
10630 appendPQExpBufferStr(query,
10631 "SELECT oid, tableoid, "
10632 "defaclrole, "
10633 "defaclnamespace, "
10634 "defaclobjtype, "
10635 "defaclacl, "
10636 "CASE WHEN defaclnamespace = 0 THEN "
10637 "acldefault(CASE WHEN defaclobjtype = 'S' "
10638 "THEN 's'::\"char\" ELSE defaclobjtype END, "
10639 "defaclrole) ELSE '{}' END AS acldefault "
10640 "FROM pg_default_acl");
10641
10643
10644 ntups = PQntuples(res);
10645
10647
10655
10657 {
10659
10664 /* cheesy ... is it worth coming up with a better object name? */
10666
10669 else
10671
10678
10679 /* Default ACLs are ACLs, of course */
10681
10682 /* Decide whether we want to dump it */
10684 }
10685
10686 PQclear(res);
10687
10688 destroyPQExpBuffer(query);
10689}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_DEFAULT_ACL, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, InvalidOid, nspid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableDefaultACL().
Referenced by getSchemaData().
◆ getDependencies()
Definition at line 20194 of file pg_dump.c.
20195{
20196 PQExpBuffer query;
20197 PGresult *res;
20198 int ntups,
20199 i;
20201 i_objid,
20202 i_refclassid,
20203 i_refobjid,
20204 i_deptype;
20205 DumpableObject *dobj,
20206 *refdobj;
20207
20209
20210 query = createPQExpBuffer();
20211
20212 /*
20213 * Messy query to collect the dependency data we need. Note that we
20214 * ignore the sub-object column, so that dependencies of or on a column
20215 * look the same as dependencies of or on a whole table.
20216 *
20217 * PIN dependencies aren't interesting, and EXTENSION dependencies were
20218 * already processed by getExtensionMembership.
20219 */
20221 "classid, objid, refclassid, refobjid, deptype "
20222 "FROM pg_depend "
20223 "WHERE deptype != 'p' AND deptype != 'e'\n");
20224
20225 /*
20226 * Since we don't treat pg_amop entries as separate DumpableObjects, we
20227 * have to translate their dependencies into dependencies of their parent
20228 * opfamily. Ignore internal dependencies though, as those will point to
20229 * their parent opclass, which we needn't consider here (and if we did,
20230 * it'd just result in circular dependencies). Also, "loose" opfamily
20231 * entries will have dependencies on their parent opfamily, which we
20232 * should drop since they'd likewise become useless self-dependencies.
20233 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
20234 */
20236 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
20237 "FROM pg_depend d, pg_amop o "
20238 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20239 "classid = 'pg_amop'::regclass AND objid = o.oid "
20240 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n");
20241
20242 /* Likewise for pg_amproc entries */
20244 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
20245 "FROM pg_depend d, pg_amproc p "
20246 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20247 "classid = 'pg_amproc'::regclass AND objid = p.oid "
20248 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n");
20249
20250 /* Sort the output for efficiency below */
20252
20254
20255 ntups = PQntuples(res);
20256
20262
20263 /*
20264 * Since we ordered the SELECT by referencing ID, we can expect that
20265 * multiple entries for the same object will appear together; this saves
20266 * on searches.
20267 */
20268 dobj = NULL;
20269
20271 {
20272 CatalogId objId;
20274 char deptype;
20275
20281
20285 dobj = findObjectByCatalogId(objId);
20286
20287 /*
20288 * Failure to find objects mentioned in pg_depend is not unexpected,
20289 * since for example we don't collect info about TOAST tables.
20290 */
20292 {
20293#ifdef NOT_USED
20296#endif
20297 continue;
20298 }
20299
20301
20303 {
20304#ifdef NOT_USED
20307#endif
20308 continue;
20309 }
20310
20311 /*
20312 * For 'x' dependencies, mark the object for later; we still add the
20313 * normal dependency, for possible ordering purposes. Currently
20314 * pg_dump_sort.c knows to put extensions ahead of all object types
20315 * that could possibly depend on them, but this is safer.
20316 */
20317 if (deptype == 'x')
20319
20320 /*
20321 * Ordinarily, table rowtypes have implicit dependencies on their
20322 * tables. However, for a composite type the implicit dependency goes
20323 * the other way in pg_depend; which is the right thing for DROP but
20324 * it doesn't produce the dependency ordering we need. So in that one
20325 * case, we reverse the direction of the dependency.
20326 */
20327 if (deptype == 'i' &&
20331 else
20332 /* normal case */
20334 }
20335
20336 PQclear(res);
20337
20338 destroyPQExpBuffer(query);
20339}
References addObjectDependency(), appendPQExpBufferStr(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::depends_on_ext, destroyPQExpBuffer(), DO_TABLE, DO_TYPE, _dumpableObject::dumpId, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), i, _dumpableObject::objType, CatalogId::oid, pg_log_info, pg_log_warning, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ getDomainConstraints()
Definition at line 8490 of file pg_dump.c.
8491{
8494 PGresult *res;
8496 i_oid,
8497 i_conname,
8498 i_consrc,
8499 i_convalidated,
8500 i_contype;
8501 int ntups;
8502
8504 {
8505 /*
8506 * Set up query for constraint-specific details. For servers 17 and
8507 * up, domains have constraints of type 'n' as well as 'c', otherwise
8508 * just the latter.
8509 */
8510 appendPQExpBuffer(query,
8511 "PREPARE getDomainConstraints(pg_catalog.oid) AS\n"
8512 "SELECT tableoid, oid, conname, "
8513 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8514 "convalidated, contype "
8515 "FROM pg_catalog.pg_constraint "
8516 "WHERE contypid = $1 AND contype IN (%s) "
8517 "ORDER BY conname",
8519
8521
8523 }
8524
8525 printfPQExpBuffer(query,
8526 "EXECUTE getDomainConstraints('%u')",
8527 tyinfo->dobj.catId.oid);
8528
8530
8531 ntups = PQntuples(res);
8532
8539
8542
8543 /* 'i' tracks result rows; 'j' counts CHECK constraints */
8545 {
8548 ConstraintInfo *constraint;
8549
8551 {
8553 tyinfo->nDomChecks++;
8554 }
8555 else
8556 {
8559 /* use last item in array for the not-null constraint */
8561 constraint = tyinfo->notnull;
8562 }
8563
8572 constraint->contype = contype;
8575 constraint->conindex = 0;
8579
8581
8582 /*
8583 * Make the domain depend on the constraint, ensuring it won't be
8584 * output till any constraint dependencies are OK. If the constraint
8585 * has not been validated, it's going to be dumped after the domain
8586 * anyway, so this doesn't matter.
8587 */
8590 }
8591
8592 PQclear(res);
8593
8594 destroyPQExpBuffer(query);
8595}
References addObjectDependency(), appendPQExpBuffer(), Assert, AssignDumpId(), atooid, _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::confrelid, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_CONSTRAINT, _constraintInfo::dobj, _dumpableObject::dumpId, ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), i, InvalidOid, j, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, PREPQUERY_GETDOMAINCONSTRAINTS, printfPQExpBuffer(), _constraintInfo::separate, and CatalogId::tableoid.
Referenced by getTypes().
◆ getEventTriggers()
Definition at line 8895 of file pg_dump.c.
8896{
8898 PQExpBuffer query;
8899 PGresult *res;
8902 i_oid,
8903 i_evtname,
8904 i_evtevent,
8905 i_evtowner,
8906 i_evttags,
8907 i_evtfname,
8908 i_evtenabled;
8909 int ntups;
8910
8911 /* Before 9.3, there are no event triggers */
8913 return;
8914
8915 query = createPQExpBuffer();
8916
8917 appendPQExpBufferStr(query,
8918 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8919 "evtevent, evtowner, "
8920 "array_to_string(array("
8921 "select quote_literal(x) "
8922 " from unnest(evttags) as t(x)), ', ') as evttags, "
8923 "e.evtfoid::regproc as evtfname "
8924 "FROM pg_event_trigger e "
8925 "ORDER BY e.oid");
8926
8928
8929 ntups = PQntuples(res);
8930
8932
8941
8943 {
8955
8956 /* Decide whether we want to dump it */
8958 }
8959
8960 PQclear(res);
8961
8962 destroyPQExpBuffer(query);
8963}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_EVENT_TRIGGER, ExecuteSqlQuery(), fb(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getExtendedStatistics()
Definition at line 8226 of file pg_dump.c.
8227{
8228 PQExpBuffer query;
8229 PGresult *res;
8231 int ntups;
8240
8241 /* Extended statistics were new in v10 */
8243 return;
8244
8245 query = createPQExpBuffer();
8246
8249 "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
8250 "FROM pg_catalog.pg_statistic_ext");
8251 else
8253 "stxnamespace, stxowner, stxrelid, stxstattarget "
8254 "FROM pg_catalog.pg_statistic_ext");
8255
8257
8258 ntups = PQntuples(res);
8259
8267
8269
8271 {
8284 else
8286
8287 /* Decide whether we want to dump it */
8289
8292 }
8293
8294 PQclear(res);
8295 destroyPQExpBuffer(query);
8296}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_STATSEXT, DUMP_COMPONENT_STATISTICS, ExecuteSqlQuery(), fb(), findNamespace(), findTableByOid(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableStatisticsObject().
Referenced by getSchemaData().
◆ getExtensionMembership()
| void getExtensionMembership | ( | Archive * | fout, |
| ExtensionInfo | extinfo[], | ||
| int | numExtensions | ||
| ) |
Definition at line 19920 of file pg_dump.c.
19922{
19923 PQExpBuffer query;
19924 PGresult *res;
19925 int ntups,
19926 i;
19928 i_objid,
19929 i_refobjid;
19930 ExtensionInfo *ext;
19931
19932 /* Nothing to do if no extensions */
19934 return;
19935
19936 query = createPQExpBuffer();
19937
19938 /* refclassid constraint is redundant but may speed the search */
19940 "classid, objid, refobjid "
19941 "FROM pg_depend "
19942 "WHERE refclassid = 'pg_extension'::regclass "
19943 "AND deptype = 'e' "
19944 "ORDER BY 3");
19945
19947
19948 ntups = PQntuples(res);
19949
19953
19954 /*
19955 * Since we ordered the SELECT by referenced ID, we can expect that
19956 * multiple entries for the same extension will appear together; this
19957 * saves on searches.
19958 */
19959 ext = NULL;
19960
19962 {
19963 CatalogId objId;
19965
19969
19973
19975 {
19976 /* shouldn't happen */
19978 continue;
19979 }
19980
19981 recordExtensionMembership(objId, ext);
19982 }
19983
19984 PQclear(res);
19985
19986 destroyPQExpBuffer(query);
19987}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _extensionInfo::dobj, ExecuteSqlQuery(), fb(), findExtensionByOid(), i, CatalogId::oid, pg_log_warning, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, recordExtensionMembership(), and CatalogId::tableoid.
Referenced by getSchemaData().
◆ getExtensions()
| ExtensionInfo * getExtensions | ( | Archive * | fout, |
| int * | numExtensions | ||
| ) |
Definition at line 6137 of file pg_dump.c.
6138{
6140 PGresult *res;
6141 int ntups;
6143 PQExpBuffer query;
6153
6154 query = createPQExpBuffer();
6155
6157 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
6158 "FROM pg_extension x "
6159 "JOIN pg_namespace n ON n.oid = x.extnamespace");
6160
6162
6163 ntups = PQntuples(res);
6164 if (ntups == 0)
6166
6168
6177
6179 {
6190
6191 /* Decide whether we want to dump it */
6193 }
6194
6195cleanup:
6196 PQclear(res);
6197 destroyPQExpBuffer(query);
6198
6199 *numExtensions = ntups;
6200
6202}
References appendPQExpBufferStr(), AssignDumpId(), atooid, cleanup(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_EXTENSION, ExecuteSqlQuery(), fb(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableExtension().
Referenced by getSchemaData().
◆ getForeignDataWrappers()
Definition at line 10428 of file pg_dump.c.
10429{
10430 PGresult *res;
10431 int ntups;
10433 PQExpBuffer query;
10444
10445 query = createPQExpBuffer();
10446
10448 "fdwowner, "
10449 "fdwhandler::pg_catalog.regproc, "
10450 "fdwvalidator::pg_catalog.regproc, "
10451 "fdwacl, "
10452 "acldefault('F', fdwowner) AS acldefault, "
10453 "array_to_string(ARRAY("
10454 "SELECT quote_ident(option_name) || ' ' || "
10455 "quote_literal(option_value) "
10456 "FROM pg_options_to_table(fdwoptions) "
10457 "ORDER BY option_name"
10458 "), E',\n ') AS fdwoptions "
10459 "FROM pg_foreign_data_wrapper");
10460
10462
10463 ntups = PQntuples(res);
10464
10466
10476
10478 {
10493
10494 /* Decide whether we want to dump it */
10496
10497 /* Mark whether FDW has an ACL */
10500 }
10501
10502 PQclear(res);
10503
10504 destroyPQExpBuffer(query);
10505}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_FDW, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getForeignServers()
Definition at line 10512 of file pg_dump.c.
10513{
10514 PGresult *res;
10515 int ntups;
10517 PQExpBuffer query;
10529
10530 query = createPQExpBuffer();
10531
10533 "srvowner, "
10534 "srvfdw, srvtype, srvversion, srvacl, "
10535 "acldefault('S', srvowner) AS acldefault, "
10536 "array_to_string(ARRAY("
10537 "SELECT quote_ident(option_name) || ' ' || "
10538 "quote_literal(option_value) "
10539 "FROM pg_options_to_table(srvoptions) "
10540 "ORDER BY option_name"
10541 "), E',\n ') AS srvoptions "
10542 "FROM pg_foreign_server");
10543
10545
10546 ntups = PQntuples(res);
10547
10549
10560
10562 {
10578
10579 /* Decide whether we want to dump it */
10581
10582 /* Servers have user mappings */
10584
10585 /* Mark whether server has an ACL */
10588 }
10589
10590 PQclear(res);
10591
10592 destroyPQExpBuffer(query);
10593}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_FOREIGN_SERVER, DUMP_COMPONENT_ACL, DUMP_COMPONENT_USERMAP, ExecuteSqlQuery(), fb(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getFormattedOperatorName()
Definition at line 14383 of file pg_dump.c.
14384{
14386
14387 /* In all cases "0" means a null reference */
14390
14393 {
14395 oproid);
14397 }
14398
14401 oprInfo->dobj.name);
14402}
References atooid, fb(), findOprByOid(), fmtId(), pg_log_warning, and psprintf().
◆ getFormattedTypeName()
Definition at line 20601 of file pg_dump.c.
20602{
20604 char *result;
20605 PQExpBuffer query;
20606 PGresult *res;
20607
20608 if (oid == 0)
20609 {
20611 return "*";
20613 return "NONE";
20614 }
20615
20616 /* see if we have the result cached in the type's TypeInfo record */
20620
20621 query = createPQExpBuffer();
20623 oid);
20624
20626
20627 /* result of format_type is already quoted */
20629
20630 PQclear(res);
20631 destroyPQExpBuffer(query);
20632
20633 /*
20634 * Cache the result for re-use in later requests, if possible. If we
20635 * don't have a TypeInfo for the type, the string will be leaked once the
20636 * caller is done with it ... but that case really should not happen, so
20637 * leaking if it does seems acceptable.
20638 */
20640 typeInfo->ftypname = result;
20641
20642 return result;
20643}
References appendPQExpBuffer(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), findTypeByOid(), opts, pg_strdup(), PQclear, PQgetvalue, zeroAsNone, and zeroAsStar.
Referenced by dumpBaseType(), dumpCast(), dumpFunc(), dumpTableSchema(), dumpTransform(), format_aggregate_signature(), and format_function_signature().
◆ getFuncs()
Definition at line 6927 of file pg_dump.c.
6928{
6930 PGresult *res;
6931 int ntups;
6934 FuncInfo *finfo;
6946
6947 /*
6948 * Find all interesting functions. This is a bit complicated:
6949 *
6950 * 1. Always exclude aggregates; those are handled elsewhere.
6951 *
6952 * 2. Always exclude functions that are internally dependent on something
6953 * else, since presumably those will be created as a result of creating
6954 * the something else. This currently acts only to suppress constructor
6955 * functions for range types. Note this is OK only because the
6956 * constructors don't have any dependencies the range type doesn't have;
6957 * otherwise we might not get creation ordering correct.
6958 *
6959 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
6960 * they're members of extensions and we are in binary-upgrade mode then
6961 * include them, since we want to dump extension members individually in
6962 * that mode. Also, if they are used by casts or transforms then we need
6963 * to gather the information about them, though they won't be dumped if
6964 * they are built-in. Also, in 9.6 and up, include functions in
6965 * pg_catalog if they have an ACL different from what's shown in
6966 * pg_init_privs (so we have to join to pg_init_privs; annoying).
6967 */
6969 {
6971
6973 : "NOT p.proisagg");
6974
6975 appendPQExpBuffer(query,
6976 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
6977 "p.pronargs, p.proargtypes, p.prorettype, "
6978 "p.proacl, "
6979 "acldefault('f', p.proowner) AS acldefault, "
6980 "p.pronamespace, "
6981 "p.proowner "
6982 "FROM pg_proc p "
6983 "LEFT JOIN pg_init_privs pip ON "
6984 "(p.oid = pip.objoid "
6985 "AND pip.classoid = 'pg_proc'::regclass "
6986 "AND pip.objsubid = 0) "
6987 "WHERE %s"
6988 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
6989 "WHERE classid = 'pg_proc'::regclass AND "
6990 "objid = p.oid AND deptype = 'i')"
6991 "\n AND ("
6992 "\n pronamespace != "
6993 "(SELECT oid FROM pg_namespace "
6994 "WHERE nspname = 'pg_catalog')"
6995 "\n OR EXISTS (SELECT 1 FROM pg_cast"
6996 "\n WHERE pg_cast.oid > %u "
6997 "\n AND p.oid = pg_cast.castfunc)"
6998 "\n OR EXISTS (SELECT 1 FROM pg_transform"
6999 "\n WHERE pg_transform.oid > %u AND "
7000 "\n (p.oid = pg_transform.trffromsql"
7001 "\n OR p.oid = pg_transform.trftosql))",
7002 not_agg_check,
7003 g_last_builtin_oid,
7004 g_last_builtin_oid);
7006 appendPQExpBufferStr(query,
7007 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7008 "classid = 'pg_proc'::regclass AND "
7009 "objid = p.oid AND "
7010 "refclassid = 'pg_extension'::regclass AND "
7011 "deptype = 'e')");
7012 appendPQExpBufferStr(query,
7013 "\n OR p.proacl IS DISTINCT FROM pip.initprivs");
7015 }
7016 else
7017 {
7018 appendPQExpBuffer(query,
7019 "SELECT tableoid, oid, proname, prolang, "
7020 "pronargs, proargtypes, prorettype, proacl, "
7021 "acldefault('f', proowner) AS acldefault, "
7022 "pronamespace, "
7023 "proowner "
7024 "FROM pg_proc p "
7025 "WHERE NOT proisagg"
7026 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
7027 "WHERE classid = 'pg_proc'::regclass AND "
7028 "objid = p.oid AND deptype = 'i')"
7029 "\n AND ("
7030 "\n pronamespace != "
7031 "(SELECT oid FROM pg_namespace "
7032 "WHERE nspname = 'pg_catalog')"
7033 "\n OR EXISTS (SELECT 1 FROM pg_cast"
7034 "\n WHERE pg_cast.oid > '%u'::oid"
7035 "\n AND p.oid = pg_cast.castfunc)",
7036 g_last_builtin_oid);
7037
7039 appendPQExpBuffer(query,
7040 "\n OR EXISTS (SELECT 1 FROM pg_transform"
7041 "\n WHERE pg_transform.oid > '%u'::oid"
7042 "\n AND (p.oid = pg_transform.trffromsql"
7043 "\n OR p.oid = pg_transform.trftosql))",
7044 g_last_builtin_oid);
7045
7047 appendPQExpBufferStr(query,
7048 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7049 "classid = 'pg_proc'::regclass AND "
7050 "objid = p.oid AND "
7051 "refclassid = 'pg_extension'::regclass AND "
7052 "deptype = 'e')");
7054 }
7055
7057
7058 ntups = PQntuples(res);
7059
7061
7073
7075 {
7093 else
7094 {
7098 }
7100
7101 /* Decide whether we want to dump it */
7103
7104 /* Mark whether function has an ACL */
7107 }
7108
7109 PQclear(res);
7110
7111 destroyPQExpBuffer(query);
7112}
References _dumpableAcl::acl, _dumpableAcl::acldefault, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _funcInfo::argtypes, AssignDumpId(), atooid, _dumpOptions::binary_upgrade, _dumpableObject::catId, _dumpableObject::components, createPQExpBuffer(), _funcInfo::dacl, PQExpBufferData::data, destroyPQExpBuffer(), DO_FUNC, _funcInfo::dobj, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), findNamespace(), g_last_builtin_oid, getRoleName(), i, _dumpableAcl::initprivs, _funcInfo::lang, _dumpableObject::name, _funcInfo::nargs, _dumpableObject::objType, CatalogId::oid, parseOidArray(), pg_malloc(), pg_malloc0(), pg_strdup(), PGRES_TUPLES_OK, _funcInfo::postponed_def, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, _dumpableAcl::privtype, _funcInfo::prorettype, _funcInfo::rolname, selectDumpableObject(), and CatalogId::tableoid.
Referenced by getSchemaData().
◆ getIndexes()
Definition at line 7857 of file pg_dump.c.
7858{
7861 PGresult *res;
7862 int ntups;
7866 i_oid,
7867 i_indrelid,
7868 i_indexname,
7869 i_relpages,
7870 i_reltuples,
7871 i_relallvisible,
7872 i_relallfrozen,
7873 i_parentidx,
7874 i_indexdef,
7875 i_indnkeyatts,
7876 i_indnatts,
7877 i_indkey,
7878 i_indisclustered,
7879 i_indisreplident,
7880 i_indnullsnotdistinct,
7881 i_contype,
7882 i_conname,
7883 i_condeferrable,
7884 i_condeferred,
7885 i_conperiod,
7886 i_contableoid,
7887 i_conoid,
7888 i_condef,
7889 i_indattnames,
7890 i_tablespace,
7891 i_indreloptions,
7892 i_indstatcols,
7893 i_indstatvals;
7894
7895 /*
7896 * We want to perform just one query against pg_index. However, we
7897 * mustn't try to select every row of the catalog and then sort it out on
7898 * the client side, because some of the server-side functions we need
7899 * would be unsafe to apply to tables we don't have lock on. Hence, we
7900 * build an array of the OIDs of tables we care about (and now have lock
7901 * on!), and use a WHERE clause to constrain which rows are selected.
7902 */
7905 {
7907
7909 continue;
7910
7911 /*
7912 * We can ignore indexes of uninteresting tables.
7913 */
7915 continue;
7916
7917 /* OK, we need info for this table */
7921 }
7923
7924 appendPQExpBufferStr(query,
7925 "SELECT t.tableoid, t.oid, i.indrelid, "
7926 "t.relname AS indexname, "
7927 "t.relpages, t.reltuples, t.relallvisible, ");
7928
7931 else
7933
7934 appendPQExpBufferStr(query,
7935 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7936 "i.indkey, i.indisclustered, "
7937 "c.contype, c.conname, "
7938 "c.condeferrable, c.condeferred, "
7939 "c.tableoid AS contableoid, "
7940 "c.oid AS conoid, "
7941 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7942 "CASE WHEN i.indexprs IS NOT NULL THEN "
7943 "(SELECT pg_catalog.array_agg(attname ORDER BY attnum)"
7944 " FROM pg_catalog.pg_attribute "
7945 " WHERE attrelid = i.indexrelid) "
7946 "ELSE NULL END AS indattnames, "
7947 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7948 "t.reloptions AS indreloptions, ");
7949
7950
7952 appendPQExpBufferStr(query,
7953 "i.indisreplident, ");
7954 else
7955 appendPQExpBufferStr(query,
7956 "false AS indisreplident, ");
7957
7959 appendPQExpBufferStr(query,
7960 "inh.inhparent AS parentidx, "
7961 "i.indnkeyatts AS indnkeyatts, "
7962 "i.indnatts AS indnatts, "
7963 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7964 " FROM pg_catalog.pg_attribute "
7965 " WHERE attrelid = i.indexrelid AND "
7966 " attstattarget >= 0) AS indstatcols, "
7967 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7968 " FROM pg_catalog.pg_attribute "
7969 " WHERE attrelid = i.indexrelid AND "
7970 " attstattarget >= 0) AS indstatvals, ");
7971 else
7972 appendPQExpBufferStr(query,
7973 "0 AS parentidx, "
7974 "i.indnatts AS indnkeyatts, "
7975 "i.indnatts AS indnatts, "
7976 "'' AS indstatcols, "
7977 "'' AS indstatvals, ");
7978
7980 appendPQExpBufferStr(query,
7981 "i.indnullsnotdistinct, ");
7982 else
7983 appendPQExpBufferStr(query,
7984 "false AS indnullsnotdistinct, ");
7985
7987 appendPQExpBufferStr(query,
7988 "c.conperiod ");
7989 else
7990 appendPQExpBufferStr(query,
7991 "NULL AS conperiod ");
7992
7993 /*
7994 * The point of the messy-looking outer join is to find a constraint that
7995 * is related by an internal dependency link to the index. If we find one,
7996 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
7997 * index won't have more than one internal dependency.
7998 *
7999 * Note: the check on conrelid is redundant, but useful because that
8000 * column is indexed while conindid is not.
8001 */
8003 {
8004 appendPQExpBuffer(query,
8005 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8006 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8007 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8008 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
8009 "LEFT JOIN pg_catalog.pg_constraint c "
8010 "ON (i.indrelid = c.conrelid AND "
8011 "i.indexrelid = c.conindid AND "
8012 "c.contype IN ('p','u','x')) "
8013 "LEFT JOIN pg_catalog.pg_inherits inh "
8014 "ON (inh.inhrelid = indexrelid) "
8015 "WHERE (i.indisvalid OR t2.relkind = 'p') "
8016 "AND i.indisready "
8017 "ORDER BY i.indrelid, indexname",
8018 tbloids->data);
8019 }
8020 else
8021 {
8022 /*
8023 * the test on indisready is necessary in 9.2, and harmless in
8024 * earlier/later versions
8025 */
8026 appendPQExpBuffer(query,
8027 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8028 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8029 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8030 "LEFT JOIN pg_catalog.pg_constraint c "
8031 "ON (i.indrelid = c.conrelid AND "
8032 "i.indexrelid = c.conindid AND "
8033 "c.contype IN ('p','u','x')) "
8034 "WHERE i.indisvalid AND i.indisready "
8035 "ORDER BY i.indrelid, indexname",
8036 tbloids->data);
8037 }
8038
8040
8041 ntups = PQntuples(res);
8042
8072
8074
8075 /*
8076 * Outer loop iterates once per table, not once per row. Incrementing of
8077 * j is handled by the inner loop.
8078 */
8079 curtblindx = -1;
8081 {
8085 int nindAttNames = 0;
8087
8088 /* Count rows for this table */
8091 break;
8092
8093 /*
8094 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8095 * order.
8096 */
8098 {
8101 break;
8102 }
8105 /* cross-check that we only got requested tables */
8107 !tbinfo->interesting)
8109 tbinfo->dobj.name);
8110
8111 /* Save data for this table */
8114
8116 {
8117 char contype;
8123
8147 {
8149 };
8150
8153 else
8155
8157 {
8159 &indAttNames, &nindAttNames))
8161 }
8162
8165 relallvisible, relallfrozen, indexkind,
8166 indAttNames, nindAttNames);
8167
8169 if (contype == 'p' || contype == 'u' || contype == 'x')
8170 {
8171 /*
8172 * If we found a constraint matching the index, create an
8173 * entry for it.
8174 */
8176
8187 constrinfo->contype = contype;
8188 if (contype == 'x')
8190 else
8199
8203 }
8204 else
8205 {
8206 /* Plain secondary index */
8208 }
8209 }
8210 }
8211
8212 PQclear(res);
8213
8214 destroyPQExpBuffer(query);
8216}
References addObjectDependency(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_CONSTRAINT, DO_INDEX, _constraintInfo::dobj, ExecuteSqlQuery(), fb(), getRelationStatistics(), i, InvalidOid, j, _dumpableObject::objType, parseOidArray(), parsePGArray(), pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, and PQntuples.
Referenced by getSchemaData().
◆ getInherits()
Definition at line 7741 of file pg_dump.c.
7742{
7743 PGresult *res;
7744 int ntups;
7748
7751
7752 /* find all the inheritance information */
7754
7756
7757 ntups = PQntuples(res);
7758
7759 *numInherits = ntups;
7760
7762
7765
7767 {
7770 }
7771
7772 PQclear(res);
7773
7774 destroyPQExpBuffer(query);
7775
7777}
References appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), i, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, and PQntuples.
Referenced by getSchemaData().
◆ getLOs()
Definition at line 3960 of file pg_dump.c.
3961{
3964 PGresult *res;
3965 int ntups;
3967 int n;
3972
3974
3975 /*
3976 * Fetch LO OIDs and owner/ACL data. Order the data so that all the blobs
3977 * with the same owner/ACL appear together.
3978 */
3980 "SELECT oid, lomowner, lomacl, "
3981 "acldefault('L', lomowner) AS acldefault "
3982 "FROM pg_largeobject_metadata "
3983 "ORDER BY lomowner, lomacl::pg_catalog.text, oid");
3984
3986
3991
3992 ntups = PQntuples(res);
3993
3994 /*
3995 * Group the blobs into suitably-sized groups that have the same owner and
3996 * ACL setting, and build a metadata and a data DumpableObject for each
3997 * group. (If we supported initprivs for blobs, we'd have to insist that
3998 * groups also share initprivs settings, since the DumpableObject only has
3999 * room for one.) i is the index of the first tuple in the current group,
4000 * and n is the number of tuples we include in the group.
4001 */
4003 {
4010
4011 /* Scan to find first tuple not to be included in group */
4012 n = 1;
4014 {
4017 break;
4018 n++;
4019 }
4020
4021 /* Build the metadata DumpableObject */
4023
4028
4029 if (n > 1)
4032 else
4037 loinfo->dacl.privtype = 0;
4040 loinfo->numlos = n;
4042 /* Collect OIDs of the remaining blobs in this group */
4043 for (int k = 1; k < n; k++)
4044 {
4046
4048
4049 /* Make sure we can look up loinfo by any of the blobs' OIDs */
4053 }
4054
4055 /* LOs have data */
4057
4058 /* Mark whether LO group has a non-empty ACL */
4061
4062 /*
4063 * In binary-upgrade mode for LOs, we do *not* dump out the LO data,
4064 * as it will be copied by pg_upgrade, which simply copies the
4065 * pg_largeobject table. We *do* however dump out anything but the
4066 * data, as pg_upgrade copies just pg_largeobject, but not
4067 * pg_largeobject_metadata, after the dump is restored. In versions
4068 * before v12, this is done via proper large object commands. In
4069 * newer versions, we dump the content of pg_largeobject_metadata and
4070 * any associated pg_shdepend rows, which is faster to restore. (On
4071 * <v12, pg_largeobject_metadata was created WITH OIDS, so the OID
4072 * column is hidden and won't be dumped.)
4073 */
4075 {
4077 {
4078 /*
4079 * We should've saved pg_largeobject_metadata's dump ID before
4080 * this point.
4081 */
4083
4085
4086 /*
4087 * Mark the large object as dependent on
4088 * pg_largeobject_metadata so that any large object
4089 * comments/seclables are dumped after it.
4090 */
4094 }
4095 else
4097 }
4098
4099 /*
4100 * Create a "BLOBS" data item for the group, too. This is just a
4101 * placeholder for sorting; it carries no data now.
4102 */
4109 /* Set up explicit dependency from data to metadata */
4113 }
4114
4115 PQclear(res);
4117}
References appendPQExpBufferStr(), Assert, AssignDumpId(), atooid, _dumpOptions::binary_upgrade, createPQExpBuffer(), destroyPQExpBuffer(), DO_LARGE_OBJECT, DO_LARGE_OBJECT_DATA, DUMP_COMPONENT_ACL, DUMP_COMPONENT_DATA, DUMP_COMPONENT_DEFINITION, ExecuteSqlQuery(), fb(), getRoleName(), i, lo_metadata_dumpId, MAX_BLOBS_PER_ARCHIVE_ENTRY, nilCatalogId, _dumpableObject::objType, pg_log_info, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, recordAdditionalCatalogID(), and snprintf.
Referenced by main().
◆ getNamespaces()
Definition at line 6005 of file pg_dump.c.
6006{
6007 PGresult *res;
6008 int ntups;
6010 PQExpBuffer query;
6018
6019 query = createPQExpBuffer();
6020
6021 /*
6022 * we fetch all namespaces including system ones, so that every object we
6023 * read in can be linked to a containing namespace.
6024 */
6026 "n.nspowner, "
6027 "n.nspacl, "
6028 "acldefault('n', n.nspowner) AS acldefault "
6029 "FROM pg_namespace n");
6030
6032
6033 ntups = PQntuples(res);
6034
6036
6043
6045 {
6046 const char *nspowner;
6047
6060
6061 /* Decide whether to dump this namespace */
6063
6064 /* Mark whether namespace has an ACL */
6067
6068 /*
6069 * We ignore any pg_init_privs.initprivs entry for the public schema
6070 * and assume a predetermined default, for several reasons. First,
6071 * dropping and recreating the schema removes its pg_init_privs entry,
6072 * but an empty destination database starts with this ACL nonetheless.
6073 * Second, we support dump/reload of public schema ownership changes.
6074 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
6075 * initprivs continues to reflect the initial owner. Hence,
6076 * synthesize the value that nspacl will have after the restore's
6077 * ALTER SCHEMA OWNER. Third, this makes the destination database
6078 * match the source's ACL, even if the latter was an initdb-default
6079 * ACL, which changed in v15. An upgrade pulls in changes to most
6080 * system object ACLs that the DBA had not customized. We've made the
6081 * public schema depart from that, because changing its ACL so easily
6082 * breaks applications.
6083 */
6085 {
6088
6089 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
6100
6104
6107 }
6108 }
6109
6110 PQclear(res);
6111 destroyPQExpBuffer(query);
6112}
References appendPGArray(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_NAMESPACE, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, pstrdup(), quoteAclUserName(), resetPQExpBuffer(), rolname, and selectDumpableNamespace().
Referenced by getSchemaData().
◆ getOpclasses()
Definition at line 6658 of file pg_dump.c.
6659{
6660 PGresult *res;
6661 int ntups;
6671
6672 /*
6673 * find all opclasses, including builtin opclasses; we filter out
6674 * system-defined opclasses at dump-out time.
6675 */
6676
6678 "opcnamespace, "
6679 "opcowner "
6680 "FROM pg_opclass");
6681
6683
6684 ntups = PQntuples(res);
6685
6687
6694
6696 {
6706
6707 /* Decide whether we want to dump it */
6709 }
6710
6711 PQclear(res);
6712
6713 destroyPQExpBuffer(query);
6714}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_OPCLASS, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getOperators()
Definition at line 6380 of file pg_dump.c.
6381{
6382 PGresult *res;
6383 int ntups;
6396
6397 /*
6398 * find all operators, including builtin operators; we filter out
6399 * system-defined operators at dump-out time.
6400 */
6401
6403 "oprnamespace, "
6404 "oprowner, "
6405 "oprkind, "
6406 "oprleft, "
6407 "oprright, "
6408 "oprcode::oid AS oprcode "
6409 "FROM pg_operator");
6410
6412
6413 ntups = PQntuples(res);
6414
6416
6426
6428 {
6441
6442 /* Decide whether we want to dump it */
6444 }
6445
6446 PQclear(res);
6447
6448 destroyPQExpBuffer(query);
6449}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_OPERATOR, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getOpfamilies()
Definition at line 6721 of file pg_dump.c.
6722{
6723 PGresult *res;
6724 int ntups;
6726 PQExpBuffer query;
6734
6735 query = createPQExpBuffer();
6736
6737 /*
6738 * find all opfamilies, including builtin opfamilies; we filter out
6739 * system-defined opfamilies at dump-out time.
6740 */
6741
6743 "opfnamespace, "
6744 "opfowner "
6745 "FROM pg_opfamily");
6746
6748
6749 ntups = PQntuples(res);
6750
6752
6759
6761 {
6771
6772 /* Decide whether we want to dump it */
6774 }
6775
6776 PQclear(res);
6777
6778 destroyPQExpBuffer(query);
6779}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_OPFAMILY, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getOwnedSeqs()
Definition at line 7676 of file pg_dump.c.
7677{
7679
7680 /*
7681 * Force sequences that are "owned" by table columns to be dumped whenever
7682 * their owning table is being dumped.
7683 */
7685 {
7687 TableInfo *owning_tab;
7688
7690 continue; /* not an owned sequence */
7691
7696
7697 /*
7698 * For an identity sequence, dump exactly the same components for the
7699 * sequence as for the owning table. This is important because we
7700 * treat the identity sequence as an integral part of the table. For
7701 * example, there is not any DDL command that allows creation of such
7702 * a sequence independently of the table.
7703 *
7704 * For other owned sequences such as serial sequences, we need to dump
7705 * the components that are being dumped for the table and any
7706 * components that the sequence is explicitly marked with.
7707 *
7708 * We can't simply use the set of components which are being dumped
7709 * for the table as the table might be in an extension (and only the
7710 * non-extension components, eg: ACLs if changed, security labels, and
7711 * policies, are being dumped) while the sequence is not (and
7712 * therefore the definition and other components should also be
7713 * dumped).
7714 *
7715 * If the sequence is part of the extension then it should be properly
7716 * marked by checkExtensionMembership() and this will be a no-op as
7717 * the table will be equivalently marked.
7718 */
7721 else
7723
7724 /* Make sure that necessary data is available if we're dumping it */
7726 {
7729 }
7730 }
7731}
References _tableInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_NONE, fb(), findTableByOid(), i, _tableInfo::interesting, OidIsValid, and pg_fatal.
Referenced by getSchemaData().
◆ getPartitioningInfo()
Definition at line 7797 of file pg_dump.c.
7798{
7799 PQExpBuffer query;
7800 PGresult *res;
7801 int ntups;
7802
7803 /* hash partitioning didn't exist before v11 */
7805 return;
7806 /* needn't bother if not dumping data */
7808 return;
7809
7810 query = createPQExpBuffer();
7811
7812 /*
7813 * Unsafe partitioning schemes are exactly those for which hash enum_ops
7814 * appears among the partition opclasses. We needn't check partstrat.
7815 *
7816 * Note that this query may well retrieve info about tables we aren't
7817 * going to dump and hence have no lock on. That's okay since we need not
7818 * invoke any unsafe server-side functions.
7819 */
7820 appendPQExpBufferStr(query,
7821 "SELECT partrelid FROM pg_partitioned_table WHERE\n"
7822 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7823 "ON c.opcmethod = a.oid\n"
7824 "WHERE opcname = 'enum_ops' "
7825 "AND opcnamespace = 'pg_catalog'::regnamespace "
7826 "AND amname = 'hash') = ANY(partclass)");
7827
7829
7830 ntups = PQntuples(res);
7831
7833 {
7836
7840 tabrelid);
7842 }
7843
7844 PQclear(res);
7845
7846 destroyPQExpBuffer(query);
7847}
References appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), findTableByOid(), i, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetvalue, and PQntuples.
Referenced by getSchemaData().
◆ getPolicies()
Definition at line 4261 of file pg_dump.c.
4262{
4264 PQExpBuffer query;
4266 PGresult *res;
4278 j,
4279 ntups;
4280
4281 /* No policies before 9.5 */
4283 return;
4284
4285 /* Skip if --no-policies was specified */
4287 return;
4288
4289 query = createPQExpBuffer();
4291
4292 /*
4293 * Identify tables of interest, and check which ones have RLS enabled.
4294 */
4297 {
4299
4300 /* Ignore row security on tables not to be dumped */
4302 continue;
4303
4304 /* It can't have RLS or policies if it's not a table */
4307 continue;
4308
4309 /* Add it to the list of table OIDs to be probed below */
4313
4314 /* Is RLS enabled? (That's separate from whether it has policies) */
4316 {
4318
4319 /*
4320 * We represent RLS being enabled on a table by creating a
4321 * PolicyInfo object with null polname.
4322 *
4323 * Note: use tableoid 0 so that this object won't be mistaken for
4324 * something that pg_depend entries apply to.
4325 */
4328 polinfo->dobj.catId.tableoid = 0;
4336 polinfo->polpermissive = 0;
4340 }
4341 }
4343
4344 /*
4345 * Now, read all RLS policies belonging to the tables of interest, and
4346 * create PolicyInfo objects for them. (Note that we must filter the
4347 * results server-side not locally, because we dare not apply pg_get_expr
4348 * to tables we don't have lock on.)
4349 */
4351
4352 printfPQExpBuffer(query,
4353 "SELECT pol.oid, pol.tableoid, pol.polrelid, pol.polname, pol.polcmd, ");
4356 else
4358 appendPQExpBuffer(query,
4359 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
4360 " 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, "
4361 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
4362 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
4363 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
4364 "JOIN pg_catalog.pg_policy pol ON (src.tbloid = pol.polrelid)",
4365 tbloids->data);
4366
4368
4369 ntups = PQntuples(res);
4370 if (ntups > 0)
4371 {
4381
4383
4385 {
4388
4390
4400
4403
4406 else
4408
4411 else
4413
4416 else
4419 }
4420 }
4421
4422 PQclear(res);
4423
4424 destroyPQExpBuffer(query);
4426}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_POLICY, DUMP_COMPONENT_POLICY, ExecuteSqlQuery(), fb(), findTableByOid(), i, j, _dumpOptions::no_policies, pg_log_info, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and printfPQExpBuffer().
Referenced by getSchemaData().
◆ getProcLangs()
Definition at line 8973 of file pg_dump.c.
8974{
8975 PGresult *res;
8976 int ntups;
8990
8992 "lanname, lanpltrusted, lanplcallfoid, "
8993 "laninline, lanvalidator, "
8994 "lanacl, "
8995 "acldefault('l', lanowner) AS acldefault, "
8996 "lanowner "
8997 "FROM pg_language "
8998 "WHERE lanispl "
8999 "ORDER BY oid");
9000
9002
9003 ntups = PQntuples(res);
9004
9006
9017
9019 {
9024
9035
9036 /* Decide whether we want to dump it */
9038
9039 /* Mark whether language has an ACL */
9042 }
9043
9044 PQclear(res);
9045
9046 destroyPQExpBuffer(query);
9047}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_PROCLANG, DUMP_COMPONENT_ACL, ExecuteSqlQuery(), fb(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableProcLang().
Referenced by getSchemaData().
◆ getPublicationNamespaces()
Definition at line 4770 of file pg_dump.c.
4771{
4772 PQExpBuffer query;
4773 PGresult *res;
4781 j,
4782 ntups;
4783
4785 return;
4786
4787 query = createPQExpBuffer();
4788
4789 /* Collect all publication membership info. */
4790 appendPQExpBufferStr(query,
4791 "SELECT tableoid, oid, pnpubid, pnnspid "
4792 "FROM pg_catalog.pg_publication_namespace");
4794
4795 ntups = PQntuples(res);
4796
4801
4802 /* this allocation may be more than we need */
4804 j = 0;
4805
4807 {
4812
4813 /*
4814 * Ignore any entries for which we aren't interested in either the
4815 * publication or the rel.
4816 */
4819 continue;
4822 continue;
4823
4824 /* OK, make a DumpableObject for this relationship */
4834
4835 /* Decide whether we want to dump it */
4837
4838 j++;
4839 }
4840
4841 PQclear(res);
4842 destroyPQExpBuffer(query);
4843}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_PUBLICATION_TABLE_IN_SCHEMA, ExecuteSqlQuery(), fb(), findNamespaceByOid(), findPublicationByOid(), i, j, _dumpOptions::no_publications, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpablePublicationObject().
Referenced by getSchemaData().
◆ getPublications()
Definition at line 4551 of file pg_dump.c.
4552{
4554 PQExpBuffer query;
4555 PGresult *res;
4570 ntups;
4571
4573 return;
4574
4575 query = createPQExpBuffer();
4576
4577 /* Get the publications. */
4579 "p.pubowner, p.puballtables, p.pubinsert, "
4580 "p.pubupdate, p.pubdelete, ");
4581
4584 else
4586
4589 else
4591
4594 else
4596
4599 else
4601
4603
4605
4606 ntups = PQntuples(res);
4607
4608 if (ntups == 0)
4610
4623
4625
4627 {
4651
4652 /* Decide whether we want to dump it */
4654 }
4655
4656cleanup:
4657 PQclear(res);
4658
4659 destroyPQExpBuffer(query);
4660}
References appendPQExpBuffer(), appendPQExpBufferStr(), AssignDumpId(), atooid, cleanup(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_PUBLICATION, ExecuteSqlQuery(), fb(), getRoleName(), i, _dumpOptions::no_publications, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getPublicationTables()
Definition at line 4850 of file pg_dump.c.
4851{
4852 PQExpBuffer query;
4853 PGresult *res;
4863 j,
4864 ntups;
4865
4867 return;
4868
4869 query = createPQExpBuffer();
4870
4871 /* Collect all publication membership info. */
4873 appendPQExpBufferStr(query,
4874 "SELECT tableoid, oid, prpubid, prrelid, "
4875 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4876 "(CASE\n"
4877 " WHEN pr.prattrs IS NOT NULL THEN\n"
4878 " (SELECT array_agg(attname)\n"
4879 " FROM\n"
4880 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4881 " pg_catalog.pg_attribute\n"
4882 " WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
4883 " ELSE NULL END) prattrs "
4884 "FROM pg_catalog.pg_publication_rel pr");
4885 else
4886 appendPQExpBufferStr(query,
4887 "SELECT tableoid, oid, prpubid, prrelid, "
4888 "NULL AS prrelqual, NULL AS prattrs "
4889 "FROM pg_catalog.pg_publication_rel");
4891
4892 ntups = PQntuples(res);
4893
4900
4901 /* this allocation may be more than we need */
4903 j = 0;
4904
4906 {
4911
4912 /*
4913 * Ignore any entries for which we aren't interested in either the
4914 * publication or the rel.
4915 */
4918 continue;
4921 continue;
4922
4923 /* OK, make a DumpableObject for this relationship */
4935 else
4937
4939 {
4940 char **attnames;
4943
4945 &attnames, &nattnames))
4949 {
4950 if (k > 0)
4952
4954 }
4957 free(attnames);
4958 }
4959 else
4961
4962 /* Decide whether we want to dump it */
4964
4965 j++;
4966 }
4967
4968 PQclear(res);
4969 destroyPQExpBuffer(query);
4970}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_PUBLICATION_REL, ExecuteSqlQuery(), fb(), findPublicationByOid(), findTableByOid(), fmtId(), free, i, j, _dumpOptions::no_publications, parsePGArray(), pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpablePublicationObject().
Referenced by getSchemaData().
◆ getRelationStatistics()
|
static |
Definition at line 7122 of file pg_dump.c.
7126{
7129
7131 (relkind == RELKIND_PARTITIONED_TABLE) ||
7132 (relkind == RELKIND_INDEX) ||
7133 (relkind == RELKIND_PARTITIONED_INDEX) ||
7134 (relkind == RELKIND_MATVIEW ||
7135 relkind == RELKIND_FOREIGN_TABLE))
7136 {
7139
7143 AssignDumpId(dobj);
7146 dobj->nDeps = 1;
7147 dobj->allocDeps = 1;
7150 dobj->namespace = rel->namespace;
7151 info->relpages = relpages;
7153 info->relallvisible = relallvisible;
7154 info->relallfrozen = relallfrozen;
7155 info->relkind = relkind;
7156 info->indAttNames = indAttNames;
7157 info->nindAttNames = nindAttNames;
7158
7159 /*
7160 * Ordinarily, stats go in SECTION_DATA for tables and
7161 * SECTION_POST_DATA for indexes.
7162 *
7163 * However, the section may be updated later for materialized view
7164 * stats. REFRESH MATERIALIZED VIEW replaces the storage and resets
7165 * the stats, so the stats must be restored after the data. Also, the
7166 * materialized view definition may be postponed to SECTION_POST_DATA
7167 * (see repairMatViewBoundaryMultiLoop()).
7168 */
7170 {
7176 break;
7180 break;
7181 default:
7183 info->relkind);
7184 }
7185
7186 return info;
7187 }
7189}
References _dumpableObject::allocDeps, AssignDumpId(), _dumpableObject::catId, _dumpableObject::components, _dumpableObject::dependencies, DO_REL_STATS, _relStatsInfo::dobj, DUMP_COMPONENT_STATISTICS, _dumpableObject::dumpId, fb(), _relStatsInfo::indAttNames, _dumpableObject::name, _dumpableObject::nDeps, _relStatsInfo::nindAttNames, _dumpableObject::objType, CatalogId::oid, pg_fatal, pg_malloc(), pg_malloc0(), pg_strdup(), pstrdup(), _relStatsInfo::relallfrozen, _relStatsInfo::relallvisible, _relStatsInfo::relkind, _relStatsInfo::relpages, _relStatsInfo::reltuples, _relStatsInfo::section, SECTION_DATA, SECTION_POST_DATA, and CatalogId::tableoid.
Referenced by getIndexes(), and getTables().
◆ getRoleName()
Definition at line 10697 of file pg_dump.c.
10698{
10700
10701 /*
10702 * Do binary search to find the appropriate item.
10703 */
10705 {
10708
10709 while (low <= high)
10710 {
10712
10714 high = middle - 1;
10716 low = middle + 1;
10717 else
10719 }
10720 }
10721
10724}
References atooid, fb(), nrolenames, pg_fatal, RoleNameItem::rolename, and rolenames.
Referenced by dumpDatabase(), getAggregates(), getCollations(), getConversions(), getDefaultACLs(), getEventTriggers(), getExtendedStatistics(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getProcLangs(), getPublications(), getSubscriptions(), getTables(), getTSConfigurations(), getTSDictionaries(), and getTypes().
◆ getRootTableInfo()
Definition at line 2831 of file pg_dump.c.
2832{
2834
2837
2840 {
2843 }
2844
2846}
Referenced by dumpTableData(), and dumpTableData_insert().
◆ getRules()
Definition at line 8602 of file pg_dump.c.
8603{
8604 PGresult *res;
8605 int ntups;
8616
8618 "tableoid, oid, rulename, "
8619 "ev_class AS ruletable, ev_type, is_instead, "
8620 "ev_enabled "
8621 "FROM pg_rewrite "
8622 "ORDER BY oid");
8623
8625
8626 ntups = PQntuples(res);
8627
8629
8637
8639 {
8641
8650 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
8658 {
8659 /*
8660 * If the table is a view or materialized view, force its ON
8661 * SELECT rule to be sorted before the view itself --- this
8662 * ensures that any dependencies for the rule affect the table's
8663 * positioning. Other rules are forced to appear after their
8664 * table.
8665 */
8669 {
8672 /* We'll merge the rule into CREATE VIEW, if possible */
8674 }
8675 else
8676 {
8680 }
8681 }
8682 else
8684 }
8685
8686 PQclear(res);
8687
8688 destroyPQExpBuffer(query);
8689}
References addObjectDependency(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_RULE, ExecuteSqlQuery(), fb(), findTableByOid(), i, pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, and PQntuples.
Referenced by getSchemaData().
◆ getSubscriptionRelations()
Definition at line 5341 of file pg_dump.c.
5342{
5346 PGresult *res;
5351 int ntups;
5353
5355 fout->remoteVersion < 170000)
5356 return;
5357
5359 "SELECT srsubid, srrelid, srsubstate, srsublsn "
5360 "FROM pg_catalog.pg_subscription_rel "
5361 "ORDER BY srsubid",
5362 PGRES_TUPLES_OK);
5363 ntups = PQntuples(res);
5364 if (ntups == 0)
5366
5367 /* Get pg_subscription_rel attributes */
5372
5375 {
5378 TableInfo *tblinfo;
5379
5380 /*
5381 * If we switched to a new subscription, check if the subscription
5382 * exists.
5383 */
5385 {
5389
5391 }
5392
5393 tblinfo = findTableByOid(relid);
5396 relid);
5397
5398 /* OK, make a DumpableObject for this relationship */
5410 else
5412
5413 /* Decide whether we want to dump it */
5415 }
5416
5417cleanup:
5418 PQclear(res);
5419}
References AssignDumpId(), atooid, _dumpOptions::binary_upgrade, cleanup(), DO_SUBSCRIPTION_REL, _tableInfo::dobj, ExecuteSqlQuery(), fb(), findSubscriptionByOid(), findTableByOid(), i, InvalidOid, _dumpableObject::name, _dumpOptions::no_subscriptions, pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getSubscriptions()
Definition at line 5121 of file pg_dump.c.
5122{
5124 PQExpBuffer query;
5125 PGresult *res;
5126 SubscriptionInfo *subinfo;
5148 ntups;
5149
5151 return;
5152
5154 {
5155 int n;
5156
5158 "SELECT count(*) FROM pg_subscription "
5159 "WHERE subdbid = (SELECT oid FROM pg_database"
5160 " WHERE datname = current_database())",
5161 PGRES_TUPLES_OK);
5163 if (n > 0)
5165 PQclear(res);
5166 return;
5167 }
5168
5169 query = createPQExpBuffer();
5170
5171 /* Get the subscriptions in current database. */
5172 appendPQExpBufferStr(query,
5173 "SELECT s.tableoid, s.oid, s.subname,\n"
5174 " s.subowner,\n"
5175 " s.subconninfo, s.subslotname, s.subsynccommit,\n"
5176 " s.subpublications,\n");
5177
5180 else
5182
5185 else
5187
5189 appendPQExpBufferStr(query,
5190 " s.subtwophasestate,\n"
5191 " s.subdisableonerr,\n");
5192 else
5193 appendPQExpBuffer(query,
5194 " '%c' AS subtwophasestate,\n"
5195 " false AS subdisableonerr,\n",
5197
5199 appendPQExpBufferStr(query,
5200 " s.subpasswordrequired,\n"
5201 " s.subrunasowner,\n"
5202 " s.suborigin,\n");
5203 else
5204 appendPQExpBuffer(query,
5205 " 't' AS subpasswordrequired,\n"
5206 " 't' AS subrunasowner,\n"
5207 " '%s' AS suborigin,\n",
5208 LOGICALREP_ORIGIN_ANY);
5209
5212 " s.subenabled,\n");
5213 else
5215 " false AS subenabled,\n");
5216
5218 appendPQExpBufferStr(query,
5219 " s.subfailover,\n");
5220 else
5221 appendPQExpBufferStr(query,
5222 " false AS subfailover,\n");
5223
5225 appendPQExpBufferStr(query,
5226 " s.subretaindeadtuples,\n");
5227 else
5228 appendPQExpBufferStr(query,
5229 " false AS subretaindeadtuples,\n");
5230
5232 appendPQExpBufferStr(query,
5233 " s.submaxretention\n");
5234 else
5235 appendPQExpBuffer(query,
5236 " 0 AS submaxretention\n");
5237
5238 appendPQExpBufferStr(query,
5239 "FROM pg_subscription s\n");
5240
5242 appendPQExpBufferStr(query,
5243 "LEFT JOIN pg_catalog.pg_replication_origin_status o \n"
5244 " ON o.external_id = 'pg_' || s.oid::text \n");
5245
5246 appendPQExpBufferStr(query,
5247 "WHERE s.subdbid = (SELECT oid FROM pg_database\n"
5248 " WHERE datname = current_database())");
5249
5251
5252 ntups = PQntuples(res);
5253
5254 /*
5255 * Get subscription fields. We don't include subskiplsn in the dump as
5256 * after restoring the dump this value may no longer be relevant.
5257 */
5278
5280
5282 {
5290
5313 else
5323 else
5326
5327 /* Decide whether we want to dump it */
5329 }
5330 PQclear(res);
5331
5332 destroyPQExpBuffer(query);
5333}
References appendPQExpBuffer(), appendPQExpBufferStr(), AssignDumpId(), atooid, _dumpOptions::binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_SUBSCRIPTION, _SubscriptionInfo::dobj, ExecuteSqlQuery(), fb(), getRoleName(), i, is_superuser(), _dumpableObject::name, _dumpOptions::no_subscriptions, _dumpableObject::objType, CatalogId::oid, pg_log_warning, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, _SubscriptionInfo::rolname, selectDumpableObject(), _SubscriptionInfo::subbinary, _SubscriptionInfo::subconninfo, _SubscriptionInfo::subdisableonerr, _SubscriptionInfo::subenabled, _SubscriptionInfo::subfailover, _SubscriptionInfo::submaxretention, _SubscriptionInfo::suborigin, _SubscriptionInfo::suboriginremotelsn, _SubscriptionInfo::subpasswordrequired, _SubscriptionInfo::subpublications, _SubscriptionInfo::subretaindeadtuples, _SubscriptionInfo::subrunasowner, _SubscriptionInfo::subslotname, _SubscriptionInfo::substream, _SubscriptionInfo::subsynccommit, _SubscriptionInfo::subtwophasestate, and CatalogId::tableoid.
Referenced by getSchemaData().
◆ getTableAttrs()
Definition at line 9251 of file pg_dump.c.
9252{
9258 PGresult *res;
9259 int ntups;
9285
9286 /*
9287 * We want to perform just one query against pg_attribute, and then just
9288 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
9289 * (for CHECK constraints and for NOT NULL constraints). However, we
9290 * mustn't try to select every row of those catalogs and then sort it out
9291 * on the client side, because some of the server-side functions we need
9292 * would be unsafe to apply to tables we don't have lock on. Hence, we
9293 * build an array of the OIDs of tables we care about (and now have lock
9294 * on!), and use a WHERE clause to constrain which rows are selected.
9295 */
9299 {
9301
9302 /* Don't bother to collect info for sequences */
9304 continue;
9305
9306 /*
9307 * Don't bother with uninteresting tables, either. For binary
9308 * upgrades, this is bypassed for pg_largeobject_metadata and
9309 * pg_shdepend so that the columns names are collected for the
9310 * corresponding COPY commands. Restoring the data for those catalogs
9311 * is faster than restoring the equivalent set of large object
9312 * commands. We can only do this for upgrades from v12 and newer; in
9313 * older versions, pg_largeobject_metadata was created WITH OIDS, so
9314 * the OID column is hidden and won't be dumped.
9315 */
9320 continue;
9321
9322 /* OK, we need info for this table */
9326
9328 {
9329 /* Also make a list of the ones with check constraints */
9333 }
9334 }
9337
9338 /*
9339 * Find all the user attributes and their types.
9340 *
9341 * Since we only want to dump COLLATE clauses for attributes whose
9342 * collation is different from their type's default, we use a CASE here to
9343 * suppress uninteresting attcollations cheaply.
9344 */
9345 appendPQExpBufferStr(q,
9346 "SELECT\n"
9347 "a.attrelid,\n"
9348 "a.attnum,\n"
9349 "a.attname,\n"
9350 "a.attstattarget,\n"
9351 "a.attstorage,\n"
9352 "t.typstorage,\n"
9353 "a.atthasdef,\n"
9354 "a.attisdropped,\n"
9355 "a.attlen,\n"
9356 "a.attalign,\n"
9357 "a.attislocal,\n"
9358 "pg_catalog.format_type(t.oid, a.atttypmod) AS atttypname,\n"
9359 "array_to_string(a.attoptions, ', ') AS attoptions,\n"
9360 "CASE WHEN a.attcollation <> t.typcollation "
9361 "THEN a.attcollation ELSE 0 END AS attcollation,\n"
9362 "pg_catalog.array_to_string(ARRAY("
9363 "SELECT pg_catalog.quote_ident(option_name) || "
9364 "' ' || pg_catalog.quote_literal(option_value) "
9365 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
9366 "ORDER BY option_name"
9367 "), E',\n ') AS attfdwoptions,\n");
9368
9369 /*
9370 * Find out any NOT NULL markings for each column. In 18 and up we read
9371 * pg_constraint to obtain the constraint name, and for valid constraints
9372 * also pg_description to obtain its comment. notnull_noinherit is set
9373 * according to the NO INHERIT property. For versions prior to 18, we
9374 * store an empty string as the name when a constraint is marked as
9375 * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
9376 * without a name); also, such cases are never NO INHERIT.
9377 *
9378 * For invalid constraints, we need to store their OIDs for processing
9379 * elsewhere, so we bring the pg_constraint.oid value when the constraint
9380 * is invalid, and NULL otherwise. Their comments are handled not here
9381 * but by collectComments, because they're their own dumpable object.
9382 *
9383 * We track in notnull_islocal whether the constraint was defined directly
9384 * in this table or via an ancestor, for binary upgrade. flagInhAttrs
9385 * might modify this later.
9386 */
9388 appendPQExpBufferStr(q,
9389 "co.conname AS notnull_name,\n"
9390 "CASE WHEN co.convalidated THEN pt.description"
9391 " ELSE NULL END AS notnull_comment,\n"
9392 "CASE WHEN NOT co.convalidated THEN co.oid "
9393 "ELSE NULL END AS notnull_invalidoid,\n"
9394 "co.connoinherit AS notnull_noinherit,\n"
9395 "co.conislocal AS notnull_islocal,\n");
9396 else
9397 appendPQExpBufferStr(q,
9398 "CASE WHEN a.attnotnull THEN '' ELSE NULL END AS notnull_name,\n"
9399 "NULL AS notnull_comment,\n"
9400 "NULL AS notnull_invalidoid,\n"
9401 "false AS notnull_noinherit,\n"
9402 "CASE WHEN a.attislocal THEN true\n"
9403 " WHEN a.attnotnull AND NOT a.attislocal THEN true\n"
9404 " ELSE false\n"
9405 "END AS notnull_islocal,\n");
9406
9408 appendPQExpBufferStr(q,
9409 "a.attcompression AS attcompression,\n");
9410 else
9411 appendPQExpBufferStr(q,
9412 "'' AS attcompression,\n");
9413
9415 appendPQExpBufferStr(q,
9416 "a.attidentity,\n");
9417 else
9418 appendPQExpBufferStr(q,
9419 "'' AS attidentity,\n");
9420
9422 appendPQExpBufferStr(q,
9423 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
9424 "THEN a.attmissingval ELSE null END AS attmissingval,\n");
9425 else
9426 appendPQExpBufferStr(q,
9427 "NULL AS attmissingval,\n");
9428
9430 appendPQExpBufferStr(q,
9431 "a.attgenerated\n");
9432 else
9433 appendPQExpBufferStr(q,
9434 "'' AS attgenerated\n");
9435
9436 /* need left join to pg_type to not fail on dropped columns ... */
9437 appendPQExpBuffer(q,
9438 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9439 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
9440 "LEFT JOIN pg_catalog.pg_type t "
9441 "ON (a.atttypid = t.oid)\n",
9442 tbloids->data);
9443
9444 /*
9445 * In versions 18 and up, we need pg_constraint for explicit NOT NULL
9446 * entries and pg_description to get their comments.
9447 */
9449 appendPQExpBufferStr(q,
9450 " LEFT JOIN pg_catalog.pg_constraint co ON "
9451 "(a.attrelid = co.conrelid\n"
9452 " AND co.contype = 'n' AND "
9453 "co.conkey = array[a.attnum])\n"
9454 " LEFT JOIN pg_catalog.pg_description pt ON "
9455 "(pt.classoid = co.tableoid AND pt.objoid = co.oid)\n");
9456
9457 appendPQExpBufferStr(q,
9458 "WHERE a.attnum > 0::pg_catalog.int2\n"
9459 "ORDER BY a.attrelid, a.attnum");
9460
9462
9463 ntups = PQntuples(res);
9464
9489
9490 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
9493
9494 /*
9495 * Outer loop iterates once per table, not once per row. Incrementing of
9496 * r is handled by the inner loop.
9497 */
9498 curtblindx = -1;
9499 for (int r = 0; r < ntups;)
9500 {
9503 int numatts;
9505
9506 /* Count rows for this table */
9507 for (numatts = 1; numatts < ntups - r; numatts++)
9509 break;
9510
9511 /*
9512 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
9513 * order.
9514 */
9516 {
9519 break;
9520 }
9523 /* cross-check that we only got requested tables */
9525 (!tbinfo->interesting &&
9530 tbinfo->dobj.name);
9531
9532 /* Save data for this table */
9533 tbinfo->numatts = numatts;
9557
9559 {
9562 tbinfo->dobj.name);
9567 else
9573 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
9578
9579 /* Handle not-null constraint name and flags */
9582 i_notnull_name,
9583 i_notnull_comment,
9584 i_notnull_invalidoid,
9585 i_notnull_noinherit,
9586 i_notnull_islocal,
9587 &invalidnotnulloids);
9588
9599 }
9600
9602 {
9603 /* Collect OIDs of interesting tables that have defaults */
9607 }
9608 }
9609
9610 /* If invalidnotnulloids has any data, finalize it */
9613
9614 PQclear(res);
9615
9616 /*
9617 * Now get info about column defaults. This is skipped for a data-only
9618 * dump, as it is only needed for table schemas.
9619 */
9621 {
9622 AttrDefInfo *attrdefs;
9625
9627
9629
9631 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc\n"
9632 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9633 "JOIN pg_catalog.pg_attrdef a ON (src.tbloid = a.adrelid)\n"
9634 "ORDER BY a.adrelid, a.adnum",
9635 tbloids->data);
9636
9638
9641
9642 curtblindx = -1;
9644 {
9650
9651 /*
9652 * Locate the associated TableInfo; we rely on tblinfo[] being in
9653 * OID order.
9654 */
9656 {
9658 {
9661 break;
9662 }
9665 }
9666
9669 adnum, tbinfo->dobj.name);
9670
9671 /*
9672 * dropped columns shouldn't have defaults, but just in case,
9673 * ignore 'em
9674 */
9676 continue;
9677
9685
9688
9690
9691 /*
9692 * Figure out whether the default/generation expression should be
9693 * dumped as part of the main CREATE TABLE (or similar) command or
9694 * as a separate ALTER TABLE (or similar) command. The preference
9695 * is to put it into the CREATE command, but in some cases that's
9696 * not possible.
9697 */
9699 {
9700 /*
9701 * Column generation expressions cannot be dumped separately,
9702 * because there is no syntax for it. By setting separate to
9703 * false here we prevent the "default" from being processed as
9704 * its own dumpable object. Later, flagInhAttrs() will mark
9705 * it as not to be dumped at all, if possible (that is, if it
9706 * can be inherited from a parent).
9707 */
9709 }
9711 {
9712 /*
9713 * Defaults on a VIEW must always be dumped as separate ALTER
9714 * TABLE commands.
9715 */
9717 }
9719 {
9720 /* column will be suppressed, print default separately */
9722 }
9723 else
9724 {
9726 }
9727
9729 {
9730 /*
9731 * Mark the default as needing to appear before the table, so
9732 * that any dependencies it has must be emitted before the
9733 * CREATE TABLE. If this is not possible, we'll change to
9734 * "separate" mode while sorting dependencies.
9735 */
9737 attrdefs[j].dobj.dumpId);
9738 }
9739
9741 }
9742
9743 PQclear(res);
9744 }
9745
9746 /*
9747 * Get info about NOT NULL NOT VALID constraints. This is skipped for a
9748 * data-only dump, as it is only needed for table schemas.
9749 */
9751 {
9760
9762
9763 resetPQExpBuffer(q);
9764 appendPQExpBuffer(q,
9765 "SELECT c.tableoid, c.oid, conrelid, conname, "
9766 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9767 "conislocal, convalidated "
9768 "FROM unnest('%s'::pg_catalog.oid[]) AS src(conoid)\n"
9769 "JOIN pg_catalog.pg_constraint c ON (src.conoid = c.oid)\n"
9770 "ORDER BY c.conrelid, c.conname",
9771 invalidnotnulloids->data);
9772
9774
9777
9784
9785 /* As above, this loop iterates once per table, not once per row */
9786 curtblindx = -1;
9788 {
9792
9793 /* Count rows for this table */
9796 break;
9797
9798 /*
9799 * Locate the associated TableInfo; we rely on tblinfo[] being in
9800 * OID order.
9801 */
9803 {
9806 break;
9807 }
9810
9812 {
9828
9829 /*
9830 * All invalid not-null constraints must be dumped separately,
9831 * because CREATE TABLE would not create them as invalid, and
9832 * also because they must be created after potentially
9833 * violating data has been loaded.
9834 */
9836
9838 }
9839 }
9840 PQclear(res);
9841 }
9842
9843 /*
9844 * Get info about table CHECK constraints. This is skipped for a
9845 * data-only dump, as it is only needed for table schemas.
9846 */
9848 {
9858
9860
9861 resetPQExpBuffer(q);
9862 appendPQExpBuffer(q,
9863 "SELECT c.tableoid, c.oid, conrelid, conname, "
9864 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9865 "conislocal, convalidated "
9866 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9867 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
9868 "WHERE contype = 'c' "
9869 "ORDER BY c.conrelid, c.conname",
9870 checkoids->data);
9871
9873
9876
9884
9885 /* As above, this loop iterates once per table, not once per row */
9886 curtblindx = -1;
9888 {
9892
9893 /* Count rows for this table */
9896 break;
9897
9898 /*
9899 * Locate the associated TableInfo; we rely on tblinfo[] being in
9900 * OID order.
9901 */
9903 {
9906 break;
9907 }
9910
9912 {
9914 "expected %d check constraints on table \"%s\" but found %d",
9915 tbinfo->ncheck),
9918 exit_nicely(1);
9919 }
9920
9922
9924 {
9926
9942
9943 /*
9944 * An unvalidated constraint needs to be dumped separately, so
9945 * that potentially-violating existing data is loaded before
9946 * the constraint.
9947 */
9949
9951
9952 /*
9953 * Mark the constraint as needing to appear before the table
9954 * --- this is so that any other dependencies of the
9955 * constraint will be emitted before we try to create the
9956 * table. If the constraint is to be dumped separately, it
9957 * will be dumped after data is loaded anyway, so don't do it.
9958 * (There's an automatic dependency in the opposite direction
9959 * anyway, so don't need to add one manually here.)
9960 */
9964
9965 /*
9966 * We will detect later whether the constraint must be split
9967 * out from the table definition.
9968 */
9969 }
9970 }
9971
9972 PQclear(res);
9973 }
9974
9975 destroyPQExpBuffer(q);
9978}
References addObjectDependency(), _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), determineNotNullFlags(), DO_ATTRDEF, DO_CONSTRAINT, _attrDefInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, _dumpOptions::dumpSchema, ExecuteSqlQuery(), exit_nicely(), fb(), i, InvalidOid, j, _dumpableObject::name, ngettext, _dumpableObject::objType, CatalogId::oid, pg_fatal, pg_log_error, pg_log_error_hint, pg_log_info, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, printfPQExpBuffer(), resetPQExpBuffer(), _attrDefInfo::separate, shouldPrintColumn(), and CatalogId::tableoid.
Referenced by getSchemaData().
◆ getTableData()
|
static |
Definition at line 3034 of file pg_dump.c.
References DUMP_COMPONENT_DATA, fb(), i, makeTableDataInfo(), and _tableInfo::relkind.
Referenced by main().
◆ getTableDataFKConstraints()
Definition at line 3255 of file pg_dump.c.
3256{
3260
3261 /* Search through all the dumpable objects for FK constraints */
3264 {
3266 {
3269
3270 /* Not interesting unless both tables are to be dumped */
3273 continue;
3277 continue;
3278
3279 /*
3280 * Okay, make referencing table's TABLE_DATA object depend on the
3281 * referenced table's TABLE_DATA object.
3282 */
3284 ftable->dataObj->dobj.dumpId);
3285 }
3286 }
3288}
References addObjectDependency(), DO_FK_CONSTRAINT, fb(), findTableByOid(), free, getDumpableObjects(), and i.
Referenced by main().
◆ getTables()
Definition at line 7199 of file pg_dump.c.
7200{
7202 PGresult *res;
7203 int ntups;
7206 TableInfo *tblinfo;
7247
7248 /*
7249 * Find all the tables and table-like objects.
7250 *
7251 * We must fetch all tables in this phase because otherwise we cannot
7252 * correctly identify inherited columns, owned sequences, etc.
7253 *
7254 * We include system catalogs, so that we can work if a user table is
7255 * defined to inherit from a system catalog (pretty weird, but...)
7256 *
7257 * Note: in this phase we should collect only a minimal amount of
7258 * information about each table, basically just enough to decide if it is
7259 * interesting. In particular, since we do not yet have lock on any user
7260 * table, we MUST NOT invoke any server-side data collection functions
7261 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
7262 * wrong answers if any concurrent DDL is happening.
7263 */
7264
7265 appendPQExpBufferStr(query,
7266 "SELECT c.tableoid, c.oid, c.relname, "
7267 "c.relnamespace, c.relkind, c.reltype, "
7268 "c.relowner, "
7269 "c.relchecks, "
7270 "c.relhasindex, c.relhasrules, c.relpages, "
7271 "c.reltuples, c.relallvisible, ");
7272
7275 else
7277
7278 appendPQExpBufferStr(query,
7279 "c.relhastriggers, c.relpersistence, "
7280 "c.reloftype, "
7281 "c.relacl, "
7283 " THEN 's'::\"char\" ELSE 'r'::\"char\" END, c.relowner) AS acldefault, "
7285 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
7286 "ELSE 0 END AS foreignserver, "
7287 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
7288 "tc.oid AS toid, "
7289 "tc.relpages AS toastpages, "
7290 "tc.reloptions AS toast_reloptions, "
7291 "d.refobjid AS owning_tab, "
7292 "d.refobjsubid AS owning_col, "
7293 "tsp.spcname AS reltablespace, ");
7294
7296 appendPQExpBufferStr(query,
7297 "false AS relhasoids, ");
7298 else
7299 appendPQExpBufferStr(query,
7300 "c.relhasoids, ");
7301
7303 appendPQExpBufferStr(query,
7304 "c.relispopulated, ");
7305 else
7306 appendPQExpBufferStr(query,
7307 "'t' as relispopulated, ");
7308
7310 appendPQExpBufferStr(query,
7311 "c.relreplident, ");
7312 else
7313 appendPQExpBufferStr(query,
7314 "'d' AS relreplident, ");
7315
7317 appendPQExpBufferStr(query,
7318 "c.relrowsecurity, c.relforcerowsecurity, ");
7319 else
7320 appendPQExpBufferStr(query,
7321 "false AS relrowsecurity, "
7322 "false AS relforcerowsecurity, ");
7323
7325 appendPQExpBufferStr(query,
7326 "c.relminmxid, tc.relminmxid AS tminmxid, ");
7327 else
7328 appendPQExpBufferStr(query,
7329 "0 AS relminmxid, 0 AS tminmxid, ");
7330
7332 appendPQExpBufferStr(query,
7333 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
7334 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
7335 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
7336 else
7337 appendPQExpBufferStr(query,
7338 "c.reloptions, NULL AS checkoption, ");
7339
7341 appendPQExpBufferStr(query,
7342 "am.amname, ");
7343 else
7344 appendPQExpBufferStr(query,
7345 "NULL AS amname, ");
7346
7348 appendPQExpBufferStr(query,
7349 "(d.deptype = 'i') IS TRUE AS is_identity_sequence, ");
7350 else
7351 appendPQExpBufferStr(query,
7352 "false AS is_identity_sequence, ");
7353
7355 appendPQExpBufferStr(query,
7356 "c.relispartition AS ispartition ");
7357 else
7358 appendPQExpBufferStr(query,
7359 "false AS ispartition ");
7360
7361 /*
7362 * Left join to pg_depend to pick up dependency info linking sequences to
7363 * their owning column, if any (note this dependency is AUTO except for
7364 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
7365 * collect the spcname.
7366 */
7367 appendPQExpBufferStr(query,
7368 "\nFROM pg_class c\n"
7369 "LEFT JOIN pg_depend d ON "
7371 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
7372 "d.objsubid = 0 AND "
7373 "d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i'))\n"
7374 "LEFT JOIN pg_tablespace tsp ON (tsp.oid = c.reltablespace)\n");
7375
7376 /*
7377 * In 9.6 and up, left join to pg_am to pick up the amname.
7378 */
7380 appendPQExpBufferStr(query,
7381 "LEFT JOIN pg_am am ON (c.relam = am.oid)\n");
7382
7383 /*
7384 * We purposefully ignore toast OIDs for partitioned tables; the reason is
7385 * that versions 10 and 11 have them, but later versions do not, so
7386 * emitting them causes the upgrade to fail.
7387 */
7388 appendPQExpBufferStr(query,
7389 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
7392
7393 /*
7394 * Restrict to interesting relkinds (in particular, not indexes). Not all
7395 * relkinds are possible in older servers, but it's not worth the trouble
7396 * to emit a version-dependent list.
7397 *
7398 * Composite-type table entries won't be dumped as such, but we have to
7399 * make a DumpableObject for them so that we can track dependencies of the
7400 * composite type (pg_depend entries for columns of the composite type
7401 * link to the pg_class entry not the pg_type entry).
7402 */
7403 appendPQExpBufferStr(query,
7404 "WHERE c.relkind IN ("
7412 "ORDER BY c.oid");
7413
7415
7416 ntups = PQntuples(res);
7417
7418 *numTables = ntups;
7419
7420 /*
7421 * Extract data from result and lock dumpable tables. We do the locking
7422 * before anything else, to minimize the window wherein a table could
7423 * disappear under us.
7424 *
7425 * Note that we have to save info about all tables here, even when dumping
7426 * only one, because we don't yet know which tables might be inheritance
7427 * ancestors of the target table.
7428 */
7430
7471
7473 {
7474 /*
7475 * Arrange to fail instead of waiting forever for a table lock.
7476 *
7477 * NB: this coding assumes that the only queries issued within the
7478 * following loop are LOCK TABLEs; else the timeout may be undesirably
7479 * applied to other things too.
7480 */
7481 resetPQExpBuffer(query);
7485 }
7486
7487 resetPQExpBuffer(query);
7488
7490 {
7493
7514 else
7517 {
7520 }
7521 else
7522 {
7525 }
7542 else
7549 else
7551 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
7553
7554 /* other fields were zeroed above */
7555
7556 /*
7557 * Decide whether we want to dump this table.
7558 */
7561 else
7563
7564 /*
7565 * Now, consider the table "interesting" if we need to dump its
7566 * definition, data or its statistics. Later on, we'll skip a lot of
7567 * data collection for uninteresting tables.
7568 *
7569 * Note: the "interesting" flag will also be set by flagInhTables for
7570 * parents of interesting tables, so that we collect necessary
7571 * inheritance info even when the parents are not themselves being
7572 * dumped. This is the main reason why we need an "interesting" flag
7573 * that's separate from the components-to-dump bitmask.
7574 */
7576 (DUMP_COMPONENT_DEFINITION |
7577 DUMP_COMPONENT_DATA |
7578 DUMP_COMPONENT_STATISTICS)) != 0;
7579
7582
7583 /* Tables have data */
7585
7586 /* Mark whether table has an ACL */
7590
7591 /* Add statistics */
7593 {
7594 RelStatsInfo *stats;
7595
7597 tblinfo[i].relpages,
7599 relallvisible, relallfrozen,
7603 }
7604
7605 /*
7606 * Read-lock target tables to make sure they aren't DROPPED or altered
7607 * in schema before we get around to dumping them.
7608 *
7609 * Note that we don't explicitly lock parents of the target tables; we
7610 * assume our lock on the child is enough to prevent schema
7611 * alterations to parent tables.
7612 *
7613 * NOTE: it'd be kinda nice to lock other relations too, not only
7614 * plain or partitioned tables, but the backend doesn't presently
7615 * allow that.
7616 *
7617 * We only need to lock the table for certain components; see
7618 * pg_dump.h
7619 */
7623 {
7624 /*
7625 * Tables are locked in batches. When dumping from a remote
7626 * server this can save a significant amount of time by reducing
7627 * the number of round trips.
7628 */
7632 else
7633 {
7636
7637 /* Arbitrarily end a batch when query length reaches 100K. */
7639 {
7640 /* Lock another batch of tables. */
7643 resetPQExpBuffer(query);
7644 }
7645 }
7646 }
7647 }
7648
7650 {
7651 /* Lock the tables in the last batch. */
7654 }
7655
7657 {
7659 }
7660
7661 PQclear(res);
7662
7663 destroyPQExpBuffer(query);
7664
7665 return tblinfo;
7666}
References _dumpableAcl::acl, _dumpableAcl::acldefault, _tableInfo::amname, appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), AssignDumpId(), atooid, _dumpableObject::catId, _tableInfo::checkoption, _dumpableObject::components, CppAsString2, createPQExpBuffer(), _tableInfo::dacl, PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, _tableInfo::dobj, _tableInfo::dummy_view, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_DATA, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_NONE, DUMP_COMPONENT_STATISTICS, DUMP_COMPONENTS_REQUIRING_LOCK, ExecuteSqlQuery(), ExecuteSqlStatement(), fb(), findNamespace(), fmtQualifiedDumpable, _tableInfo::forcerowsec, _tableInfo::foreign_server, _tableInfo::frozenxid, GetConnection(), getRelationStatistics(), getRoleName(), _tableInfo::hascolumnACLs, _tableInfo::hasindex, _tableInfo::hasoids, _tableInfo::hasrules, _tableInfo::hastriggers, i, _dumpableAcl::initprivs, _tableInfo::interesting, InvalidOid, _tableInfo::is_identity_sequence, _tableInfo::ispartition, PQExpBufferData::len, _dumpOptions::lockWaitTimeout, _tableInfo::minmxid, _dumpableObject::name, _tableInfo::ncheck, _dumpableObject::objType, CatalogId::oid, _tableInfo::owning_col, _tableInfo::owning_tab, pg_malloc0(), pg_strdup(), PGRES_TUPLES_OK, _tableInfo::postponed_def, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, _dumpableAcl::privtype, _tableInfo::relispopulated, _tableInfo::relkind, _tableInfo::reloftype, _tableInfo::reloptions, _tableInfo::relpages, _tableInfo::relpersistence, _tableInfo::relreplident, _tableInfo::reltablespace, _tableInfo::reltype, resetPQExpBuffer(), _tableInfo::rolname, _tableInfo::rowsec, selectDumpableTable(), _tableInfo::stats, CatalogId::tableoid, _tableInfo::toast_frozenxid, _tableInfo::toast_minmxid, _tableInfo::toast_oid, _tableInfo::toast_reloptions, and _tableInfo::toastpages.
Referenced by getSchemaData().
◆ getTransforms()
Definition at line 9167 of file pg_dump.c.
9168{
9169 PGresult *res;
9170 int ntups;
9172 PQExpBuffer query;
9180
9181 /* Transforms didn't exist pre-9.5 */
9183 return;
9184
9185 query = createPQExpBuffer();
9186
9188 "trftype, trflang, trffromsql::oid, trftosql::oid "
9189 "FROM pg_transform "
9190 "ORDER BY 3,4");
9191
9193
9194 ntups = PQntuples(res);
9195
9197
9204
9206 {
9210
9219
9220 /*
9221 * Try to name transform as concatenation of type and language name.
9222 * This is only used for purposes of sorting. If we fail to find
9223 * either, the name will be an empty string.
9224 */
9233
9234 /* Decide whether we want to dump it */
9236 }
9237
9238 PQclear(res);
9239
9240 destroyPQExpBuffer(query);
9241}
References appendPQExpBuffer(), appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TRANSFORM, _typeInfo::dobj, ExecuteSqlQuery(), fb(), findTypeByOid(), free, get_language_name(), i, initPQExpBuffer(), _dumpableObject::objType, pg_malloc(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getTriggers()
Definition at line 8699 of file pg_dump.c.
8700{
8703 PGresult *res;
8704 int ntups;
8708 i_oid,
8709 i_tgrelid,
8710 i_tgname,
8711 i_tgenabled,
8712 i_tgispartition,
8713 i_tgdef;
8714
8715 /*
8716 * We want to perform just one query against pg_trigger. However, we
8717 * mustn't try to select every row of the catalog and then sort it out on
8718 * the client side, because some of the server-side functions we need
8719 * would be unsafe to apply to tables we don't have lock on. Hence, we
8720 * build an array of the OIDs of tables we care about (and now have lock
8721 * on!), and use a WHERE clause to constrain which rows are selected.
8722 */
8725 {
8727
8730 continue;
8731
8732 /* OK, we need info for this table */
8736 }
8738
8740 {
8741 /*
8742 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8743 * result in non-forward-compatible dumps of WHEN clauses due to
8744 * under-parenthesization.
8745 *
8746 * NB: We need to see partition triggers in case the tgenabled flag
8747 * has been changed from the parent.
8748 */
8749 appendPQExpBuffer(query,
8750 "SELECT t.tgrelid, t.tgname, "
8751 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8752 "t.tgenabled, t.tableoid, t.oid, "
8753 "t.tgparentid <> 0 AS tgispartition\n"
8754 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8755 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8756 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8757 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
8758 "OR t.tgenabled != u.tgenabled) "
8759 "ORDER BY t.tgrelid, t.tgname",
8760 tbloids->data);
8761 }
8763 {
8764 /*
8765 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8766 * result in non-forward-compatible dumps of WHEN clauses due to
8767 * under-parenthesization.
8768 *
8769 * NB: We need to see tgisinternal triggers in partitions, in case the
8770 * tgenabled flag has been changed from the parent.
8771 */
8772 appendPQExpBuffer(query,
8773 "SELECT t.tgrelid, t.tgname, "
8774 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8775 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition\n"
8776 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8777 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8778 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8779 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
8780 "ORDER BY t.tgrelid, t.tgname",
8781 tbloids->data);
8782 }
8784 {
8785 /*
8786 * NB: We need to see tgisinternal triggers in partitions, in case the
8787 * tgenabled flag has been changed from the parent. No tgparentid in
8788 * version 11-12, so we have to match them via pg_depend.
8789 *
8790 * See above about pretty=true in pg_get_triggerdef.
8791 */
8792 appendPQExpBuffer(query,
8793 "SELECT t.tgrelid, t.tgname, "
8794 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8795 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
8796 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8797 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8798 "LEFT JOIN pg_catalog.pg_depend AS d ON "
8799 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8800 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8801 " d.objid = t.oid "
8802 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
8803 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
8804 "ORDER BY t.tgrelid, t.tgname",
8805 tbloids->data);
8806 }
8807 else
8808 {
8809 /* See above about pretty=true in pg_get_triggerdef */
8810 appendPQExpBuffer(query,
8811 "SELECT t.tgrelid, t.tgname, "
8812 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8813 "t.tgenabled, false as tgispartition, "
8814 "t.tableoid, t.oid "
8815 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8816 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8817 "WHERE NOT tgisinternal "
8818 "ORDER BY t.tgrelid, t.tgname",
8819 tbloids->data);
8820 }
8821
8823
8824 ntups = PQntuples(res);
8825
8833
8835
8836 /*
8837 * Outer loop iterates once per table, not once per row. Incrementing of
8838 * j is handled by the inner loop.
8839 */
8840 curtblindx = -1;
8842 {
8846
8847 /* Count rows for this table */
8850 break;
8851
8852 /*
8853 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8854 * order.
8855 */
8857 {
8860 break;
8861 }
8864
8865 /* Save data for this table */
8868
8870 {
8881 }
8882 }
8883
8884 PQclear(res);
8885
8886 destroyPQExpBuffer(query);
8888}
References appendPQExpBuffer(), appendPQExpBufferChar(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TRIGGER, DUMP_COMPONENT_DEFINITION, ExecuteSqlQuery(), fb(), i, j, pg_fatal, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, and PQntuples.
Referenced by getSchemaData().
◆ getTSConfigurations()
Definition at line 10369 of file pg_dump.c.
10370{
10371 PGresult *res;
10372 int ntups;
10374 PQExpBuffer query;
10382
10383 query = createPQExpBuffer();
10384
10386 "cfgnamespace, cfgowner, cfgparser "
10387 "FROM pg_ts_config");
10388
10390
10391 ntups = PQntuples(res);
10392
10394
10401
10403 {
10413
10414 /* Decide whether we want to dump it */
10416 }
10417
10418 PQclear(res);
10419
10420 destroyPQExpBuffer(query);
10421}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TSCONFIG, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getTSDictionaries()
Definition at line 10244 of file pg_dump.c.
10245{
10246 PGresult *res;
10247 int ntups;
10249 PQExpBuffer query;
10258
10259 query = createPQExpBuffer();
10260
10262 "dictnamespace, dictowner, "
10263 "dicttemplate, dictinitoption "
10264 "FROM pg_ts_dict");
10265
10267
10268 ntups = PQntuples(res);
10269
10271
10279
10281 {
10293 else
10295
10296 /* Decide whether we want to dump it */
10298 }
10299
10300 PQclear(res);
10301
10302 destroyPQExpBuffer(query);
10303}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TSDICT, ExecuteSqlQuery(), fb(), findNamespace(), getRoleName(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getTSParsers()
Definition at line 10170 of file pg_dump.c.
10171{
10172 PGresult *res;
10173 int ntups;
10175 PQExpBuffer query;
10186
10187 query = createPQExpBuffer();
10188
10189 /*
10190 * find all text search objects, including builtin ones; we filter out
10191 * system-defined objects at dump-out time.
10192 */
10193
10195 "prsstart::oid, prstoken::oid, "
10196 "prsend::oid, prsheadline::oid, prslextype::oid "
10197 "FROM pg_ts_parser");
10198
10200
10201 ntups = PQntuples(res);
10202
10204
10214
10216 {
10229
10230 /* Decide whether we want to dump it */
10232 }
10233
10234 PQclear(res);
10235
10236 destroyPQExpBuffer(query);
10237}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TSPARSER, ExecuteSqlQuery(), fb(), findNamespace(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getTSTemplates()
Definition at line 10310 of file pg_dump.c.
10311{
10312 PGresult *res;
10313 int ntups;
10315 PQExpBuffer query;
10323
10324 query = createPQExpBuffer();
10325
10327 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
10328 "FROM pg_ts_template");
10329
10331
10332 ntups = PQntuples(res);
10333
10335
10342
10344 {
10354
10355 /* Decide whether we want to dump it */
10357 }
10358
10359 PQclear(res);
10360
10361 destroyPQExpBuffer(query);
10362}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TSTEMPLATE, ExecuteSqlQuery(), fb(), findNamespace(), i, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and selectDumpableObject().
Referenced by getSchemaData().
◆ getTypes()
Definition at line 6212 of file pg_dump.c.
6213{
6214 PGresult *res;
6215 int ntups;
6234
6235 /*
6236 * we include even the built-in types because those may be used as array
6237 * elements by user-defined types
6238 *
6239 * we filter out the built-in types when we dump out the types
6240 *
6241 * same approach for undefined (shell) types and array types
6242 *
6243 * Note: as of 8.3 we can reliably detect whether a type is an
6244 * auto-generated array type by checking the element type's typarray.
6245 * (Before that the test is capable of generating false positives.) We
6246 * still check for name beginning with '_', though, so as to avoid the
6247 * cost of the subselect probe for all standard types. This would have to
6248 * be revisited if the backend ever allows renaming of array types.
6249 */
6251 "typnamespace, typacl, "
6252 "acldefault('T', typowner) AS acldefault, "
6253 "typowner, "
6254 "typelem, typrelid, typarray, "
6255 "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
6256 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
6257 "typtype, typisdefined, "
6258 "typname[0] = '_' AND typelem != 0 AND "
6259 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
6260 "FROM pg_type");
6261
6263
6264 ntups = PQntuples(res);
6265
6267
6282
6284 {
6303
6306 else
6308
6311 else
6313
6315
6318 else
6320
6321 /* Decide whether we want to dump it */
6323
6324 /* Mark whether type has an ACL */
6327
6328 /*
6329 * If it's a domain, fetch info about its constraints, if any
6330 */
6337
6338 /*
6339 * If it's a base type, make a DumpableObject representing a shell
6340 * definition of the type. We will need to dump that ahead of the I/O
6341 * functions for the type. Similarly, range types need a shell
6342 * definition in case they have a canonicalize function.
6343 *
6344 * Note: the shell type doesn't have a catId. You might think it
6345 * should copy the base type's catId, but then it might capture the
6346 * pg_depend entries for the type, which we don't want.
6347 */
6351 {
6360
6361 /*
6362 * Initially mark the shell type as not to be dumped. We'll only
6363 * dump it if the I/O or canonicalize functions need to be dumped;
6364 * this is taken care of while sorting dependencies.
6365 */
6367 }
6368 }
6369
6370 PQclear(res);
6371
6372 destroyPQExpBuffer(query);
6373}
References appendPQExpBufferStr(), AssignDumpId(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_SHELL_TYPE, DO_TYPE, DUMP_COMPONENT_ACL, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_NONE, ExecuteSqlQuery(), fb(), findNamespace(), getDomainConstraints(), getRoleName(), i, nilCatalogId, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PQntuples, and selectDumpableType().
Referenced by getSchemaData().
◆ help()
Definition at line 1321 of file pg_dump.c.
1322{
1323 printf(_("%s exports a PostgreSQL database as an SQL script or to other formats.\n\n"), progname);
1326
1330 " plain text (default))\n"));
1335 " compress as specified\n"));
1340
1354 " plain-text format\n"));
1365 " access to)\n"));
1368 " do NOT dump the specified table(s), including\n"
1369 " child and partition tables\n"));
1372 " do NOT dump data for the specified table(s),\n"
1373 " including child and partition tables\n"));
1376 " based on expressions in FILENAME\n"));
1379 " include data of foreign tables on foreign\n"
1380 " servers matching PATTERN\n"));
1406 " match at least one entity each\n"));
1408 " child and partition tables\n"));
1410 " use SET SESSION AUTHORIZATION commands instead of\n"
1411 " ALTER OWNER commands to set ownership\n"));
1412
1421
1423 "variable value is used.\n\n"));
1426}
◆ is_superuser()
Definition at line 5081 of file pg_dump.c.
5082{
5085
5087
5089 return true;
5090
5091 return false;
5092}
References _archiveHandle::connection, fb(), PQparameterStatus(), and val.
◆ main()
Definition at line 424 of file pg_dump.c.
425{
429 TableInfo *tblinfo;
436 RestoreOptions *ropt;
442 int numWorkers = 1;
446 pg_compress_specification compression_spec = {0};
459
461
495
496 /*
497 * the following options don't have an equivalent short option letter
498 */
544
546 };
547
548 pg_logging_init(argv[0]);
551
552 /*
553 * Initialize what we need for parallel execution, especially for thread
554 * support on Windows.
555 */
556 init_parallel_dump_utils();
557
559
560 if (argc > 1)
561 {
563 {
565 exit_nicely(0);
566 }
568 {
570 exit_nicely(0);
571 }
572 }
573
574 InitDumpOptions(&dopt);
575
578 {
580 {
581 case 'a': /* Dump data only */
583 break;
584
585 case 'b': /* Dump LOs */
587 break;
588
589 case 'B': /* Don't dump LOs */
591 break;
592
593 case 'c': /* clean (i.e., drop) schema prior to create */
594 dopt.outputClean = 1;
595 break;
596
597 case 'C': /* Create DB */
598 dopt.outputCreateDB = 1;
599 break;
600
601 case 'd': /* database name */
603 break;
604
605 case 'e': /* include extension(s) */
608 break;
609
610 case 'E': /* Dump encoding */
612 break;
613
614 case 'f':
616 break;
617
618 case 'F':
620 break;
621
622 case 'h': /* server host */
624 break;
625
626 case 'j': /* number of dump jobs */
628 PG_MAX_JOBS,
629 &numWorkers))
630 exit_nicely(1);
631 break;
632
633 case 'n': /* include schema(s) */
636 break;
637
638 case 'N': /* exclude schema(s) */
640 break;
641
642 case 'O': /* Don't reconnect to match owner */
643 dopt.outputNoOwner = 1;
644 break;
645
646 case 'p': /* server port */
648 break;
649
650 case 'R':
651 /* no-op, still accepted for backwards compatibility */
652 break;
653
654 case 's': /* dump schema only */
656 break;
657
658 case 'S': /* Username for superuser in plain text output */
660 break;
661
662 case 't': /* include table(s) */
665 break;
666
667 case 'T': /* exclude table(s) */
669 break;
670
671 case 'U':
673 break;
674
675 case 'v': /* verbose */
678 break;
679
680 case 'w':
682 break;
683
684 case 'W':
686 break;
687
688 case 'x': /* skip ACL dump */
690 break;
691
692 case 'Z': /* Compression */
694 &compression_detail);
696 break;
697
698 case 0:
699 /* This covers the long options. */
700 break;
701
702 case 2: /* lock-wait-timeout */
704 break;
705
706 case 3: /* SET ROLE */
708 break;
709
710 case 4: /* exclude table(s) data */
712 break;
713
714 case 5: /* section */
716 break;
717
718 case 6: /* snapshot */
720 break;
721
722 case 7: /* no-sync */
724 break;
725
726 case 8:
729 &extra_float_digits))
730 exit_nicely(1);
731 break;
732
733 case 9: /* inserts */
734
735 /*
736 * dump_inserts also stores --rows-per-insert, careful not to
737 * overwrite that.
738 */
741 break;
742
743 case 10: /* rows per insert */
745 &dopt.dump_inserts))
746 exit_nicely(1);
747 break;
748
749 case 11: /* include foreign data */
751 optarg);
752 break;
753
754 case 12: /* include table(s) and their children */
756 optarg);
758 break;
759
760 case 13: /* exclude table(s) and their children */
762 optarg);
763 break;
764
765 case 14: /* exclude data of table(s) and children */
767 optarg);
768 break;
769
770 case 15:
772 exit_nicely(1);
773 break;
774
775 case 16: /* read object filters from file */
777 break;
778
779 case 17: /* exclude extension(s) */
781 optarg);
782 break;
783
784 case 18:
786 break;
787
788 case 19:
790 break;
791
792 case 20:
794 break;
795
796 case 21:
798 break;
799
800 case 22:
802 break;
803
804 case 25:
806 break;
807
808 default:
809 /* getopt_long already emitted a complaint */
811 exit_nicely(1);
812 }
813 }
814
815 /*
816 * Non-option argument specifies database name as long as it wasn't
817 * already specified with -d / --dbname
818 */
821
822 /* Complain if any arguments remain */
824 {
826 argv[optind]);
828 exit_nicely(1);
829 }
830
831 /* --column-inserts implies --inserts */
834
835 /* reject conflicting "-only" options */
838 "-s/--schema-only", "-a/--data-only");
841 "-s/--schema-only", "--statistics-only");
844 "-a/--data-only", "--statistics-only");
845
846 /* reject conflicting "-only" and "no-" options */
849 "-a/--data-only", "--no-data");
852 "-s/--schema-only", "--no-schema");
855 "--statistics-only", "--no-statistics");
856
857 /* reject conflicting "no-" options */
860 "--statistics", "--no-statistics");
861
862 /* reject conflicting "-only" options */
865 "-a/--data-only", "--statistics");
868 "-s/--schema-only", "--statistics");
869
872 "-s/--schema-only", "--include-foreign-data");
873
876 "--include-foreign-data");
877
880 "-c/--clean", "-a/--data-only");
881
884 "--if-exists", "-c/--clean");
885
886 /*
887 * Set derivative flags. Ambiguous or nonsensical combinations, e.g.
888 * "--schema-only --no-schema", will have already caused an error in one
889 * of the checks above.
890 */
897
898
899 /*
900 * --inserts are already implied above if --column-inserts or
901 * --rows-per-insert were specified.
902 */
905 "--on-conflict-do-nothing",
906 "--inserts", "--rows-per-insert", "--column-inserts");
907
908 /* Identify archive format to emit */
910
911 /* archiveFormat specific setup */
913 {
914 plainText = 1;
915
916 /*
917 * If you don't provide a restrict key, one will be appointed for you.
918 */
925 }
928 "--restrict-key", "--format=plain");
929
930 /*
931 * Custom and directory formats are compressed by default with gzip when
932 * available, not the others. If gzip is not available, no compression is
933 * done by default.
934 */
936 !user_compression_defined)
937 {
938#ifdef HAVE_LIBZ
940#else
942#endif
943 }
944
945 /*
946 * Compression options
947 */
949 &compression_algorithm))
952
954 &compression_spec);
958 error_detail);
959
963
964 /*
965 * Disable support for zstd workers for now - these are based on
966 * threading, and it's unclear how it interacts with parallel dumps on
967 * platforms where that relies on threads too (e.g. Windows).
968 */
971 "workers");
972
973 /*
974 * If emitting an archive format, we always want to emit a DATABASE item,
975 * in case --create is specified at pg_restore time.
976 */
978 dopt.outputCreateDB = 1;
979
980 /* Parallel backup only in the directory archive format so far */
983
984 /* Open the output file */
987
988 /* Make dump options accessible right away */
990
991 /* Register the cleanup hook */
993
994 /* Let the archiver know how noisy to be */
996
997
998 /*
999 * We allow the server to be back to 9.2, and up to any minor release of
1000 * our own major version. (See also version check in pg_dumpall.c.)
1001 */
1002 fout->minRemoteVersion = 90200;
1004
1005 fout->numWorkers = numWorkers;
1006
1007 /*
1008 * Open the database using the Archiver, so it knows about it. Errors mean
1009 * death.
1010 */
1013
1014 /*
1015 * On hot standbys, never try to dump unlogged table data, since it will
1016 * just throw an error.
1017 */
1020
1021 /*
1022 * Find the last built-in OID, if needed (prior to 8.1)
1023 *
1024 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
1025 */
1027
1029
1030 /* Expand schema selection patterns into OID lists */
1032 {
1034 &schema_include_oids,
1035 strict_names);
1038 }
1040 &schema_exclude_oids,
1041 false);
1042 /* non-matching exclusion patterns aren't an error */
1043
1044 /* Expand table selection patterns into OID lists */
1046 &table_include_oids,
1049 &table_include_oids,
1055
1057 &table_exclude_oids,
1058 false, false);
1060 &table_exclude_oids,
1061 false, true);
1062
1064 &tabledata_exclude_oids,
1065 false, false);
1067 &tabledata_exclude_oids,
1068 false, true);
1069
1071 &foreign_servers_include_oids);
1072
1073 /* non-matching exclusion patterns aren't an error */
1074
1075 /* Expand extension selection patterns into OID lists */
1077 {
1079 &extension_include_oids,
1080 strict_names);
1083 }
1085 &extension_exclude_oids,
1086 false);
1087 /* non-matching exclusion patterns aren't an error */
1088
1089 /*
1090 * Dumping LOs is the default for dumps where an inclusion switch is not
1091 * used (an "include everything" dump). -B can be used to exclude LOs
1092 * from those dumps. -b can be used to include LOs even when an inclusion
1093 * switch is used.
1094 *
1095 * -s means "schema only" and LOs are data, not schema, so we never
1096 * include LOs when -s is used.
1097 */
1100
1101 /*
1102 * Collect role names so we can map object owner OIDs to names.
1103 */
1105
1106 /*
1107 * Now scan the database and create DumpableObject structs for all the
1108 * objects we intend to dump.
1109 */
1111
1113 {
1117 getTableDataFKConstraints();
1118 }
1119
1122
1123 /*
1124 * For binary upgrade mode, dump pg_largeobject_metadata and the
1125 * associated pg_shdepend rows. This is faster to restore than the
1126 * equivalent set of large object commands. We can only do this for
1127 * upgrades from v12 and newer; in older versions, pg_largeobject_metadata
1128 * was created WITH OIDS, so the OID column is hidden and won't be dumped.
1129 */
1131 {
1134
1137
1138 /*
1139 * Save pg_largeobject_metadata's dump ID for use as a dependency for
1140 * pg_shdepend and any large object comments/seclabels.
1141 */
1144
1145 /*
1146 * Only dump large object shdepend rows for this database.
1147 */
1149 "AND dbid = (SELECT oid FROM pg_database "
1150 " WHERE datname = current_database())";
1151
1152 /*
1153 * If upgrading from v16 or newer, only dump large objects with
1154 * comments/seclabels. For these upgrades, pg_upgrade can copy/link
1155 * pg_largeobject_metadata's files (which is usually faster) but we
1156 * still need to dump LOs with comments/seclabels here so that the
1157 * subsequent COMMENT and SECURITY LABEL commands work. pg_upgrade
1158 * can't copy/link the files from older versions because aclitem
1159 * (needed by pg_largeobject_metadata.lomacl) changed its storage
1160 * format in v16.
1161 */
1164 "(SELECT objoid FROM pg_description "
1166 "UNION SELECT objoid FROM pg_seclabel "
1168 }
1169
1170 /*
1171 * In binary-upgrade mode, we do not have to worry about the actual LO
1172 * data or the associated metadata that resides in the pg_largeobject and
1173 * pg_largeobject_metadata tables, respectively.
1174 *
1175 * However, we do need to collect LO information as there may be comments
1176 * or other information on LOs that we do need to dump out.
1177 */
1180
1181 /*
1182 * Collect dependency data to assist in ordering the objects.
1183 */
1185
1186 /*
1187 * Collect ACLs, comments, and security labels, if wanted.
1188 */
1195
1196 /* For binary upgrade mode, collect required pg_class information. */
1199
1200 /* Collect sequence information. */
1202
1203 /* Lastly, create dummy objects to represent the section boundaries */
1205
1206 /* Get pointers to all the known DumpableObjects */
1208
1209 /*
1210 * Add dummy dependencies to enforce the dump section ordering.
1211 */
1213
1214 /*
1215 * Sort the objects into a safe dump order (no forward references).
1216 *
1217 * We rely on dependency information to help us determine a safe order, so
1218 * the initial sort is mostly for cosmetic purposes: we sort by name to
1219 * ensure that logically identical schemas will dump identically.
1220 */
1222
1225
1226 /*
1227 * Create archive TOC entries for all the objects to be dumped, in a safe
1228 * order.
1229 */
1230
1231 /*
1232 * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
1233 */
1237
1238 /* The database items are always next, unless we don't want them at all */
1241
1242 /* Now the rearrangeable objects. */
1245
1246 /*
1247 * Set up options info to ensure we dump what we want.
1248 */
1249 ropt = NewRestoreOptions();
1251
1252 /* if you change this list, see dumpOptionsFromRestoreOptions */
1286
1287 ropt->compression_spec = compression_spec;
1288
1290
1292
1293 /* Mark which entries should be output */
1295
1296 /*
1297 * The archive's TOC entries are now marked as to which ones will actually
1298 * be output, so we can set up their dependency lists properly. This isn't
1299 * necessary for plain-text output, though.
1300 */
1303
1304 /*
1305 * And finally we can do the actual output.
1306 *
1307 * Note: for non-plain-text output formats, the output file is written
1308 * inside CloseArchive(). This is, um, bizarre; but not worth changing
1309 * right now.
1310 */
1313
1315
1316 exit_nicely(0);
1317}
References _restoreOptions::aclsSkip, _dumpOptions::aclsSkip, addBoundaryDependencies(), addObjectDependency(), archCustom, archDirectory, archNull, archUnknown, _restoreOptions::binary_upgrade, _dumpOptions::binary_upgrade, BuildArchiveDependencies(), buildMatViewRefreshDependencies(), CloseArchive(), collectBinaryUpgradeClassOids(), collectComments(), collectRoleNames(), collectSecLabels(), collectSequences(), _restoreOptions::column_inserts, _dumpOptions::column_inserts, compression_algorithm, _restoreOptions::compression_spec, ConnectDatabaseAhx(), _restoreOptions::cparams, _dumpOptions::cparams, CppAsString2, CreateArchive(), createBoundaryObjects(), _restoreOptions::createDB, DATA_DIR_SYNC_METHOD_FSYNC, _connParams::dbname, _restoreOptions::disable_dollar_quoting, _dumpOptions::disable_dollar_quoting, _restoreOptions::disable_triggers, _dumpOptions::disable_triggers, _dumpOptions::do_nothing, _dumpOptions::dontOutputLOs, dosync, _restoreOptions::dropSchema, DUMP_DEFAULT_ROWS_PER_INSERT, _restoreOptions::dump_inserts, _dumpOptions::dump_inserts, _restoreOptions::dumpData, _dumpOptions::dumpData, dumpDatabase(), dumpDumpableObject(), dumpEncoding(), _restoreOptions::dumpSchema, _dumpOptions::dumpSchema, dumpSearchPath(), _restoreOptions::dumpSections, _dumpOptions::dumpSections, _restoreOptions::dumpStatistics, _dumpOptions::dumpStatistics, dumpStdStrings(), _restoreOptions::enable_row_security, _dumpOptions::enable_row_security, exit_nicely(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), extension_exclude_oids, extension_exclude_patterns, extension_include_oids, extension_include_patterns, extra_float_digits, fb(), _restoreOptions::filename, filename, findTableByOid(), FirstNormalObjectId, foreign_servers_include_oids, foreign_servers_include_patterns, format, g_last_builtin_oid, generate_restrict_key(), get_progname(), getAdditionalACLs(), getDependencies(), getDumpableObjects(), getLOs(), getopt_long(), getSchemaData(), getTableData(), getTableDataFKConstraints(), have_extra_float_digits, SimpleOidList::head, SimpleStringList::head, help(), i, _restoreOptions::if_exists, _dumpOptions::if_exists, _restoreOptions::include_everything, _dumpOptions::include_everything, init_parallel_dump_utils(), InitDumpOptions(), lo_metadata_dumpId, _dumpOptions::load_via_partition_root, _restoreOptions::lockWaitTimeout, _dumpOptions::lockWaitTimeout, makeTableDataInfo(), NewRestoreOptions(), no_argument, _restoreOptions::no_comments, _dumpOptions::no_comments, no_data, _restoreOptions::no_policies, _dumpOptions::no_policies, _restoreOptions::no_publications, _dumpOptions::no_publications, no_schema, _restoreOptions::no_security_labels, _dumpOptions::no_security_labels, no_statistics, _restoreOptions::no_subscriptions, _dumpOptions::no_subscriptions, _dumpOptions::no_toast_compression, _dumpOptions::no_unlogged_table_data, _restoreOptions::noOwner, _restoreOptions::noTableAm, _restoreOptions::noTablespace, on_exit_close_archive(), optarg, optind, option_parse_int(), pg_compress_specification::options, _dumpOptions::outputClean, _dumpOptions::outputCreateDB, _dumpOptions::outputLOs, _dumpOptions::outputNoOwner, _dumpOptions::outputNoTableAm, _dumpOptions::outputNoTablespaces, _dumpOptions::outputSuperuser, parse_compress_algorithm(), parse_compress_options(), parse_compress_specification(), parse_sync_method(), parseArchiveFormat(), PG_COMPRESSION_OPTION_WORKERS, pg_fatal, pg_log_error, pg_log_error_hint, pg_log_info, pg_log_warning, PG_LOG_WARNING, pg_logging_increase_verbosity(), pg_logging_init(), pg_logging_set_level(), PG_MAX_JOBS, pg_strdup(), PG_TEXTDOMAIN, _connParams::pghost, _connParams::pgport, ProcessArchiveRestoreOptions(), progname, _connParams::promptPassword, quote_all_identifiers, read_dump_filters(), required_argument, RestoreArchive(), _restoreOptions::restrict_key, _dumpOptions::restrict_key, schema_exclude_oids, schema_exclude_patterns, schema_include_oids, schema_include_patterns, _restoreOptions::sequence_data, _dumpOptions::sequence_data, _dumpOptions::serializable_deferrable, set_dump_section(), set_pglocale_pgservice(), SetArchiveOptions(), setup_connection(), setupDumpWorker(), simple_string_list_append(), sortDumpableObjects(), sortDumpableObjectsByTypeName(), statistics_only, strict_names, _restoreOptions::superuser, supports_compression(), _restoreOptions::suppressDumpWarnings, sync_method, table_exclude_oids, table_exclude_patterns, table_exclude_patterns_and_children, table_include_oids, table_include_patterns, table_include_patterns_and_children, tabledata_exclude_oids, tabledata_exclude_patterns, tabledata_exclude_patterns_and_children, TRI_NO, TRI_YES, _restoreOptions::use_setsessauth, _dumpOptions::use_setsessauth, _connParams::username, valid_restrict_key(), validate_compress_specification(), and with_statistics.
◆ makeTableDataInfo()
|
static |
Definition at line 3053 of file pg_dump.c.
3054{
3056
3057 /*
3058 * Nothing to do if we already decided to dump the table. This will
3059 * happen for "config" tables.
3060 */
3062 return;
3063
3064 /* Skip VIEWs (no data to dump) */
3066 return;
3067 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
3071 tbinfo->foreign_server)))
3072 return;
3073 /* Skip partitioned tables (data in partitions) */
3075 return;
3076
3077 /* Don't dump data in unlogged tables, if so requested */
3079 dopt->no_unlogged_table_data)
3080 return;
3081
3082 /* Check that the data is not explicitly excluded */
3084 tbinfo->dobj.catId.oid))
3085 return;
3086
3087 /* OK, let's dump it */
3089
3094 else
3096
3097 /*
3098 * Note: use tableoid 0 so that this object won't be mistaken for
3099 * something that pg_depend entries apply to.
3100 */
3101 tdinfo->dobj.catId.tableoid = 0;
3109
3110 /* A TableDataInfo contains data, of course */
3112
3114
3115 /*
3116 * Materialized view statistics must be restored after the data, because
3117 * REFRESH MATERIALIZED VIEW replaces the storage and resets the stats.
3118 *
3119 * The dependency is added here because the statistics objects are created
3120 * first.
3121 */
3123 {
3126 }
3127
3128 /* Make sure that we'll collect per-column info for this table. */
3130}
References addObjectDependency(), AssignDumpId(), DO_REFRESH_MATVIEW, DO_SEQUENCE_SET, DO_TABLE_DATA, _tableDataInfo::dobj, DUMP_COMPONENT_DATA, fb(), foreign_servers_include_oids, SimpleOidList::head, _dumpOptions::no_unlogged_table_data, _dumpableObject::objType, pg_malloc(), SECTION_POST_DATA, simple_oid_list_member(), and tabledata_exclude_oids.
Referenced by getTableData(), main(), and processExtensionTables().
◆ nonemptyReloptions()
Definition at line 20686 of file pg_dump.c.
20687{
20688 /* Don't want to print it if it's just "{}" */
20690}
References fb().
Referenced by dumpConstraint(), dumpRule(), and dumpTableSchema().
◆ parse_sequence_type()
Definition at line 19101 of file pg_dump.c.
19102{
19104 {
19107 }
19108
19111}
References fb(), i, lengthof, name, pg_fatal, and SeqTypeNames.
Referenced by collectSequences(), and dumpSequence().
◆ parseArchiveFormat()
|
static |
Definition at line 1639 of file pg_dump.c.
1640{
1642
1644
1646 {
1647 /* This is used by pg_dumpall, and is not documented */
1650 }
1667 else
1670}
References archCustom, archDirectory, archModeAppend, archModeWrite, archNull, archTar, fb(), format, mode, pg_fatal, and pg_strcasecmp().
Referenced by main().
◆ processExtensionTables()
| void processExtensionTables | ( | Archive * | fout, |
| ExtensionInfo | extinfo[], | ||
| int | numExtensions | ||
| ) |
Definition at line 20013 of file pg_dump.c.
20015{
20017 PQExpBuffer query;
20018 PGresult *res;
20019 int ntups,
20020 i;
20022 i_confrelid;
20023
20024 /* Nothing to do if no extensions */
20026 return;
20027
20028 /*
20029 * Identify extension configuration tables and create TableDataInfo
20030 * objects for them, ensuring their data will be dumped even though the
20031 * tables themselves won't be.
20032 *
20033 * Note that we create TableDataInfo objects even in schema-only mode, ie,
20034 * user data in a configuration table is treated like schema data. This
20035 * seems appropriate since system data in a config table would get
20036 * reloaded by CREATE EXTENSION. If the extension is not listed in the
20037 * list of extensions to be included, none of its data is dumped.
20038 */
20040 {
20048
20049 /*
20050 * Check if this extension is listed as to include in the dump. If
20051 * not, any table data associated with it is discarded.
20052 */
20055 curext->dobj.catId.oid))
20056 continue;
20057
20058 /*
20059 * Check if this extension is listed as to exclude in the dump. If
20060 * yes, any table data associated with it is discarded.
20061 */
20064 curext->dobj.catId.oid))
20065 continue;
20066
20068 {
20070
20077
20079 {
20084
20087 continue;
20088
20089 /*
20090 * Tables of not-to-be-dumped extensions shouldn't be dumped
20091 * unless the table or its schema is explicitly included
20092 */
20094 {
20095 /* check table explicitly requested */
20098 configtbloid))
20100
20101 /* check table's schema explicitly requested */
20103 DUMP_COMPONENT_DATA)
20105 }
20106
20107 /* check table excluded by an exclusion switch */
20110 configtbloid))
20112
20113 /* check schema excluded by an exclusion switch */
20115 configtbl->dobj.namespace->dobj.catId.oid))
20117
20119 {
20122 {
20125 }
20126 }
20127 }
20128 }
20133 }
20134
20135 /*
20136 * Now that all the TableDataInfo objects have been created for all the
20137 * extensions, check their FK dependencies and register them to try and
20138 * dump the data out in an order that they can be restored in.
20139 *
20140 * Note that this is not a problem for user tables as their FKs are
20141 * recreated after the data has been loaded.
20142 */
20143
20144 query = createPQExpBuffer();
20145
20146 printfPQExpBuffer(query,
20147 "SELECT conrelid, confrelid "
20148 "FROM pg_constraint "
20149 "JOIN pg_depend ON (objid = confrelid) "
20150 "WHERE contype = 'f' "
20151 "AND refclassid = 'pg_extension'::regclass "
20152 "AND classid = 'pg_class'::regclass;");
20153
20155 ntups = PQntuples(res);
20156
20159
20160 /* Now get the dependencies and register them */
20162 {
20163 Oid conrelid,
20164 confrelid;
20166 *contable;
20167
20170 contable = findTableByOid(conrelid);
20172
20175 contable == NULL ||
20177 continue;
20178
20179 /*
20180 * Make referencing TABLE_DATA object depend on the referenced table's
20181 * TABLE_DATA object.
20182 */
20185 }
20186 PQclear(res);
20187 destroyPQExpBuffer(query);
20188}
References addObjectDependency(), atooid, createPQExpBuffer(), PQExpBufferData::data, _tableInfo::dataObj, destroyPQExpBuffer(), _tableDataInfo::dobj, DUMP_COMPONENT_DATA, DUMP_COMPONENT_DEFINITION, _dumpableObject::dumpId, ExecuteSqlQuery(), _extensionInfo::extconfig, extension_exclude_oids, extension_include_oids, fb(), findTableByOid(), free, SimpleOidList::head, i, j, makeTableDataInfo(), parsePGArray(), pg_fatal, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, printfPQExpBuffer(), schema_exclude_oids, simple_oid_list_member(), table_exclude_oids, and table_include_oids.
Referenced by getSchemaData().
◆ prohibit_crossdb_refs()
|
static |
Definition at line 1937 of file pg_dump.c.
1938{
1939 const char *db;
1940
1944
1947 pattern);
1948}
References conn, dbname, fb(), pg_fatal, and PQdb().
Referenced by expand_schema_name_patterns(), and expand_table_name_patterns().
◆ read_dump_filters()
|
static |
Definition at line 20717 of file pg_dump.c.
20718{
20720 char *objname;
20722 FilterObjectType objtype;
20723
20725
20727 {
20729 {
20730 switch (objtype)
20731 {
20733 break;
20741 "include",
20742 filter_object_type_name(objtype));
20743 exit_nicely(1);
20744 break; /* unreachable */
20745
20748 break;
20751 break;
20755 break;
20759 break;
20762 objname);
20764 break;
20765 }
20766 }
20768 {
20769 switch (objtype)
20770 {
20772 break;
20779 "exclude",
20780 filter_object_type_name(objtype));
20781 exit_nicely(1);
20782 break;
20783
20786 break;
20789 objname);
20790 break;
20793 objname);
20794 break;
20797 break;
20800 break;
20803 objname);
20804 break;
20805 }
20806 }
20807 else
20808 {
20811 }
20812
20813 if (objname)
20814 free(objname);
20815 }
20816
20818}
References _, Assert, exit_nicely(), extension_exclude_patterns, extension_include_patterns, fb(), filename, FILTER_COMMAND_TYPE_EXCLUDE, FILTER_COMMAND_TYPE_INCLUDE, FILTER_COMMAND_TYPE_NONE, filter_free(), filter_init(), FILTER_OBJECT_TYPE_DATABASE, FILTER_OBJECT_TYPE_EXTENSION, FILTER_OBJECT_TYPE_FOREIGN_DATA, FILTER_OBJECT_TYPE_FUNCTION, FILTER_OBJECT_TYPE_INDEX, filter_object_type_name(), FILTER_OBJECT_TYPE_NONE, FILTER_OBJECT_TYPE_SCHEMA, FILTER_OBJECT_TYPE_TABLE, FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN, FILTER_OBJECT_TYPE_TABLE_DATA, FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN, FILTER_OBJECT_TYPE_TRIGGER, filter_read_item(), foreign_servers_include_patterns, free, _dumpOptions::include_everything, pg_log_filter_error(), schema_exclude_patterns, schema_include_patterns, simple_string_list_append(), table_exclude_patterns, table_exclude_patterns_and_children, table_include_patterns, table_include_patterns_and_children, tabledata_exclude_patterns, and tabledata_exclude_patterns_and_children.
Referenced by main().
◆ refreshMatViewData()
|
static |
Definition at line 2999 of file pg_dump.c.
3000{
3002 PQExpBuffer q;
3003
3004 /* If the materialized view is not flagged as populated, skip this. */
3006 return;
3007
3008 q = createPQExpBuffer();
3009
3012
3018 .namespace = tbinfo->dobj.namespace->dobj.name,
3019 .owner = tbinfo->rolname,
3020 .description = "MATERIALIZED VIEW DATA",
3021 .section = SECTION_POST_DATA,
3022 .createStmt = q->data,
3023 .deps = tdinfo->dobj.dependencies,
3024 .nDeps = tdinfo->dobj.nDeps));
3025
3026 destroyPQExpBuffer(q);
3027}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DATA, fb(), fmtQualifiedDumpable, and SECTION_POST_DATA.
Referenced by dumpDumpableObject().
◆ selectDumpableAccessMethod()
|
static |
Definition at line 2262 of file pg_dump.c.
2263{
2264 /* see getAccessMethods() comment about v9.6. */
2266 {
2268 return;
2269 }
2270
2272 return; /* extension membership overrides all else */
2273
2274 /*
2275 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
2276 * they do not support ACLs currently.
2277 */
2280 else
2283}
References _dumpableObject::catId, checkExtensionMembership(), _accessMethodInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, fb(), g_last_builtin_oid, and CatalogId::oid.
Referenced by getAccessMethods().
◆ selectDumpableCast()
Definition at line 2204 of file pg_dump.c.
2205{
2207 return; /* extension membership overrides all else */
2208
2209 /*
2210 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
2211 * support ACLs currently.
2212 */
2215 else
2218}
References checkExtensionMembership(), DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, fb(), and g_last_builtin_oid.
Referenced by getCasts().
◆ selectDumpableDefaultACL()
|
static |
Definition at line 2182 of file pg_dump.c.
2183{
2184 /* Default ACLs can't be extension members */
2185
2187 /* default ACLs are considered part of the namespace */
2189 else
2192}
References DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, fb(), and _dumpOptions::include_everything.
Referenced by getDefaultACLs().
◆ selectDumpableExtension()
|
static |
Definition at line 2297 of file pg_dump.c.
2298{
2299 /*
2300 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2301 * change permissions on their member objects, if they wish to, and have
2302 * those changes preserved.
2303 */
2306 else
2307 {
2308 /* check if there is a list of extensions to dump */
2312 extinfo->dobj.catId.oid) ?
2314 else
2316 dopt->include_everything ?
2318
2319 /* check that the extension is not explicitly excluded */
2322 extinfo->dobj.catId.oid))
2324 }
2325}
References DUMP_COMPONENT_ACL, DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, extension_exclude_oids, extension_include_oids, fb(), g_last_builtin_oid, SimpleOidList::head, _dumpOptions::include_everything, and simple_oid_list_member().
Referenced by getExtensions().
◆ selectDumpableNamespace()
|
static |
Definition at line 2012 of file pg_dump.c.
2013{
2014 /*
2015 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
2016 * and (for --clean) a DROP SCHEMA statement. (In the absence of
2017 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
2018 */
2020
2021 /*
2022 * If specific tables are being dumped, do not dump any complete
2023 * namespaces. If specific namespaces are being dumped, dump just those
2024 * namespaces. Otherwise, dump all non-system namespaces.
2025 */
2031 nsinfo->dobj.catId.oid) ?
2035 {
2036 /*
2037 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
2038 * they are interesting (and not the original ACLs which were set at
2039 * initdb time, see pg_init_privs).
2040 */
2042 }
2045 {
2046 /* Other system schemas don't get dumped */
2048 }
2050 {
2051 /*
2052 * The public schema is a strange beast that sits in a sort of
2053 * no-mans-land between being a system object and a user object.
2054 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
2055 * a comment and an indication of ownership. If the owner is the
2056 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
2057 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
2058 */
2064
2065 /*
2066 * Also, make like it has a comment even if it doesn't; this is so
2067 * that we'll emit a command to drop the comment, if appropriate.
2068 * (Without this, we'd not call dumpCommentExtended for it.)
2069 */
2071 }
2072 else
2074
2075 /*
2076 * In any case, a namespace can be excluded by an exclusion switch
2077 */
2080 nsinfo->dobj.catId.oid))
2082
2083 /*
2084 * If the schema belongs to an extension, allow extension membership to
2085 * override the dump decision for the schema itself. However, this does
2086 * not change dump_contains, so this won't change what we do with objects
2087 * within the schema. (If they belong to the extension, they'll get
2088 * suppressed by it, otherwise not.)
2089 */
2091}
References checkExtensionMembership(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_ALL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_NONE, fb(), SimpleOidList::head, schema_exclude_oids, schema_include_oids, simple_oid_list_member(), and table_include_oids.
Referenced by getNamespaces().
◆ selectDumpableObject()
|
static |
Definition at line 2372 of file pg_dump.c.
2373{
2375 return; /* extension membership overrides all else */
2376
2377 /*
2378 * Default policy is to dump if parent namespace is dumpable, or for
2379 * non-namespace-associated items, dump if we're dumping "everything".
2380 */
2381 if (dobj->namespace)
2383 else
2386}
References checkExtensionMembership(), _dumpableObject::dump, DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, _dumpableObject::dump_contains, and fb().
Referenced by getAggregates(), getCollations(), getConversions(), getEventTriggers(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getOpclasses(), getOperators(), getOpfamilies(), getPublications(), getSubscriptionRelations(), getSubscriptions(), getTransforms(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), and getTSTemplates().
◆ selectDumpableProcLang()
|
static |
Definition at line 2229 of file pg_dump.c.
2230{
2232 return; /* extension membership overrides all else */
2233
2234 /*
2235 * Only include procedural languages when we are dumping everything.
2236 *
2237 * For from-initdb procedural languages, only include ACLs, as we do for
2238 * the pg_catalog namespace. We need this because procedural languages do
2239 * not live in any namespace.
2240 */
2243 else
2244 {
2248 else
2250 }
2251}
References checkExtensionMembership(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, fb(), and g_last_builtin_oid.
Referenced by getProcLangs().
◆ selectDumpablePublicationObject()
|
static |
Definition at line 2336 of file pg_dump.c.
2337{
2339 return; /* extension membership overrides all else */
2340
2343}
References checkExtensionMembership(), _dumpableObject::dump, DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, and fb().
Referenced by getPublicationNamespaces(), and getPublicationTables().
◆ selectDumpableStatisticsObject()
|
static |
Definition at line 2354 of file pg_dump.c.
2355{
2357 return; /* extension membership overrides all else */
2358
2363}
References checkExtensionMembership(), DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_NONE, and fb().
Referenced by getExtendedStatistics().
◆ selectDumpableTable()
Definition at line 2098 of file pg_dump.c.
2099{
2101 return; /* extension membership overrides all else */
2102
2103 /*
2104 * If specific tables are being dumped, dump just those tables; else, dump
2105 * according to the parent namespace's dump flag.
2106 */
2109 tbinfo->dobj.catId.oid) ?
2111 else
2113
2114 /*
2115 * In any case, a table can be excluded by an exclusion switch
2116 */
2119 tbinfo->dobj.catId.oid))
2121}
References checkExtensionMembership(), DUMP_COMPONENT_ALL, DUMP_COMPONENT_NONE, fb(), SimpleOidList::head, simple_oid_list_member(), table_exclude_oids, and table_include_oids.
Referenced by getTables().
◆ selectDumpableType()
Definition at line 2137 of file pg_dump.c.
2138{
2139 /* skip complex types, except for standalone composite types */
2142 {
2144
2148 else
2150 return;
2151 }
2152
2153 /* skip auto-generated array and multirange types */
2155 {
2157
2158 /*
2159 * Fall through to set the dump flag; we assume that the subsequent
2160 * rules will do the same thing as they would for the array's base
2161 * type or multirange's range type. (We cannot reliably look up the
2162 * base type here, since getTypes may not have processed it yet.)
2163 */
2164 }
2165
2167 return; /* extension membership overrides all else */
2168
2169 /* Dump based on if the contents of the namespace are being dumped */
2171}
References checkExtensionMembership(), DO_DUMMY_TYPE, DUMP_COMPONENT_NONE, fb(), findTableByOid(), and OidIsValid.
Referenced by getTypes().
◆ SequenceItemCmp()
Definition at line 19117 of file pg_dump.c.
19118{
19121
19123}
References fb(), and pg_cmp_u32().
Referenced by dumpSequence(), and dumpSequenceData().
◆ set_restrict_relation_kind()
Definition at line 5100 of file pg_dump.c.
5101{
5103 PGresult *res;
5104
5105 appendPQExpBuffer(query,
5106 "SELECT set_config(name, '%s', false) "
5107 "FROM pg_settings "
5108 "WHERE name = 'restrict_nonsystem_relation_kind'",
5109 value);
5111
5112 PQclear(res);
5113 destroyPQExpBuffer(query);
5114}
References appendPQExpBuffer(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), PGRES_TUPLES_OK, PQclear, and value.
Referenced by dumpTableData_copy(), dumpTableData_insert(), and setup_connection().
◆ setup_connection()
|
static |
Definition at line 1429 of file pg_dump.c.
1431{
1434
1436
1437 /*
1438 * Set the client encoding if requested.
1439 */
1441 {
1444 dumpencoding);
1445 }
1446
1447 /*
1448 * Force standard_conforming_strings on, just in case we are dumping from
1449 * an old server that has it disabled. Without this, literals in views,
1450 * expressions, etc, would be incorrect for modern servers.
1451 */
1453
1454 /*
1455 * And reflect that to AH->std_strings. You might think that we should
1456 * just delete that variable and the code that checks it, but that would
1457 * be problematic for pg_restore, which at least for now should still cope
1458 * with archives containing the other setting (cf. processStdStringsEntry
1459 * in pg_backup_archiver.c).
1460 */
1462
1463 /*
1464 * Get the active encoding, so we know how to escape strings.
1465 */
1468
1469 /*
1470 * Set the role if requested. In a parallel dump worker, we'll be passed
1471 * use_role == NULL, but AH->use_role is already set (if user specified it
1472 * originally) and we should use that.
1473 */
1475 use_role = AH->use_role;
1476
1477 /* Set the role if requested */
1478 if (use_role)
1479 {
1481
1484 destroyPQExpBuffer(query);
1485
1486 /* save it for possible later use by parallel workers */
1489 }
1490
1491 /* Set the datestyle to ISO to ensure the dump's portability */
1493
1494 /* Likewise, avoid using sql_standard intervalstyle */
1496
1497 /*
1498 * Use an explicitly specified extra_float_digits if it has been provided.
1499 * Otherwise, set extra_float_digits so that we can dump float data
1500 * exactly (given correctly implemented float I/O code, anyway).
1501 */
1503 {
1505
1507 extra_float_digits);
1509 destroyPQExpBuffer(q);
1510 }
1511 else
1513
1514 /*
1515 * Disable synchronized scanning, to prevent unpredictable changes in row
1516 * ordering across a dump and reload.
1517 */
1519
1520 /*
1521 * Disable timeouts if supported.
1522 */
1530
1531 /*
1532 * Quote all identifiers, if requested.
1533 */
1536
1537 /*
1538 * Adjust row-security mode, if supported.
1539 */
1541 {
1544 else
1546 }
1547
1548 /*
1549 * For security reasons, we restrict the expansion of non-system views and
1550 * access to foreign tables during the pg_dump process. This restriction
1551 * is adjusted when dumping foreign table data.
1552 */
1554
1555 /*
1556 * Initialize prepared-query state to "nothing prepared". We do this here
1557 * so that a parallel dump worker will have its own state.
1558 */
1560
1561 /*
1562 * Start transaction-snapshot mode transaction to dump consistent data.
1563 */
1565
1566 /*
1567 * To support the combination of serializable_deferrable with the jobs
1568 * option we use REPEATABLE READ for the worker connections that are
1569 * passed a snapshot. As long as the snapshot is acquired in a
1570 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1571 * REPEATABLE READ transaction provides the appropriate integrity
1572 * guarantees. This is a kluge, but safe for back-patching.
1573 */
1575 ExecuteSqlStatement(AH,
1576 "SET TRANSACTION ISOLATION LEVEL "
1577 "SERIALIZABLE, READ ONLY, DEFERRABLE");
1578 else
1579 ExecuteSqlStatement(AH,
1580 "SET TRANSACTION ISOLATION LEVEL "
1581 "REPEATABLE READ, READ ONLY");
1582
1583 /*
1584 * If user specified a snapshot to use, select that. In a parallel dump
1585 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1586 * is already set (if the server can handle it) and we should use that.
1587 */
1590
1592 {
1594
1598 destroyPQExpBuffer(query);
1599 }
1601 {
1605 }
1606}
References ALWAYS_SECURE_SEARCH_PATH_SQL, appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), Archive::dopt, _dumpOptions::enable_row_security, Archive::encoding, ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), extra_float_digits, fb(), fmtId(), get_synchronized_snapshot(), GetConnection(), have_extra_float_digits, Archive::is_prepared, Archive::isStandby, NUM_PREP_QUERIES, Archive::numWorkers, pg_fatal, pg_malloc0(), pg_strdup(), PQclear, PQclientEncoding(), PQsetClientEncoding(), quote_all_identifiers, Archive::remoteVersion, _dumpOptions::serializable_deferrable, set_restrict_relation_kind(), setFmtEncoding(), Archive::std_strings, Archive::sync_snapshot_id, and Archive::use_role.
Referenced by main(), and setupDumpWorker().
◆ setupDumpWorker()
Definition at line 1610 of file pg_dump.c.
1611{
1612 /*
1613 * We want to re-select all the same values the leader connection is
1614 * using. We'll have inherited directly-usable values in
1615 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1616 * inherited encoding value back to a string to pass to setup_connection.
1617 */
1618 setup_connection(AH,
1620 NULL,
1621 NULL);
1622}
References Archive::encoding, fb(), pg_encoding_to_char, and setup_connection().
Referenced by CreateArchive(), and main().
◆ shouldPrintColumn()
Definition at line 10155 of file pg_dump.c.
10156{
10158 return true;
10160 return false;
10162}
References _dumpOptions::binary_upgrade, and fb().
Referenced by dumpTableSchema(), flagInhAttrs(), and getTableAttrs().
◆ StaticAssertDecl()
| StaticAssertDecl | ( | lengthof(SeqTypeNames) | = =(SEQTYPE_BIGINT+1), |
| "array length mismatch" | |||
| ) |
Variable Documentation
◆ binaryUpgradeClassOids
|
static |
Definition at line 210 of file pg_dump.c.
Referenced by binary_upgrade_set_pg_class_oids(), and collectBinaryUpgradeClassOids().
◆ comments
|
static |
Definition at line 202 of file pg_dump.c.
Referenced by collectComments(), dumpCommentExtended(), dumpCompositeTypeColComments(), dumpTableComment(), and findComments().
◆ compression_algorithm
|
static |
◆ dosync
Definition at line 152 of file pg_dump.c.
Referenced by _allocAH(), CreateArchive(), and main().
◆ extension_exclude_oids
|
static |
Definition at line 189 of file pg_dump.c.
Referenced by main(), processExtensionTables(), and selectDumpableExtension().
◆ extension_exclude_patterns
|
static |
◆ extension_include_oids
|
static |
Definition at line 186 of file pg_dump.c.
Referenced by main(), processExtensionTables(), and selectDumpableExtension().
◆ extension_include_patterns
|
static |
◆ extra_float_digits
|
static |
Definition at line 195 of file pg_dump.c.
Referenced by main(), and setup_connection().
◆ foreign_servers_include_oids
|
static |
◆ foreign_servers_include_patterns
|
static |
◆ g_last_builtin_oid
|
static |
Definition at line 154 of file pg_dump.c.
Referenced by getFuncs(), main(), selectDumpableAccessMethod(), selectDumpableCast(), selectDumpableExtension(), and selectDumpableProcLang().
◆ have_extra_float_digits
Definition at line 194 of file pg_dump.c.
Referenced by main(), and setup_connection().
◆ lo_metadata_dumpId
|
static |
◆ nbinaryUpgradeClassOids
|
static |
Definition at line 211 of file pg_dump.c.
Referenced by binary_upgrade_set_pg_class_oids(), and collectBinaryUpgradeClassOids().
◆ ncomments
|
static |
Definition at line 203 of file pg_dump.c.
Referenced by collectComments(), dumpCommentExtended(), dumpCompositeTypeColComments(), dumpTableComment(), and findComments().
◆ nilCatalogId
Definition at line 191 of file pg_dump.c.
191{0, 0};
Referenced by createBoundaryObjects(), dumpACL(), dumpCommentExtended(), dumpCompositeTypeColComments(), dumpDatabase(), dumpEncoding(), dumpRelationStats(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpStatisticsExtStats(), dumpStdStrings(), dumpTableComment(), dumpTableSchema(), dumpTableSecLabel(), dumpUserMappings(), getLOs(), and getTypes().
◆ nrolenames
|
static |
Definition at line 199 of file pg_dump.c.
Referenced by collectRoleNames(), and getRoleName().
◆ nseclabels
|
static |
Definition at line 207 of file pg_dump.c.
Referenced by collectSecLabels(), and findSecLabels().
◆ nsequences
|
static |
Definition at line 215 of file pg_dump.c.
Referenced by collectSequences(), dumpSequence(), and dumpSequenceData().
◆ rolenames
|
static |
Definition at line 198 of file pg_dump.c.
Referenced by collectRoleNames(), and getRoleName().
◆ schema_exclude_oids
|
static |
Definition at line 170 of file pg_dump.c.
Referenced by main(), processExtensionTables(), and selectDumpableNamespace().
◆ schema_exclude_patterns
|
static |
◆ schema_include_oids
|
static |
◆ schema_include_patterns
|
static |
◆ seclabels
|
static |
Definition at line 206 of file pg_dump.c.
Referenced by collectSecLabels(), and findSecLabels().
◆ SeqTypeNames
Initial value:
Definition at line 119 of file pg_dump.c.
120{
124};
Referenced by dumpSequence(), and parse_sequence_type().
◆ sequences
|
static |
Definition at line 214 of file pg_dump.c.
Referenced by collectSequences(), dumpSequence(), dumpSequenceData(), GetSubscriptionRelations(), and pg_get_publication_sequences().
◆ strict_names
|
static |
Definition at line 157 of file pg_dump.c.
Referenced by expand_extension_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), and main().
◆ table_exclude_oids
|
static |
Definition at line 177 of file pg_dump.c.
Referenced by main(), processExtensionTables(), and selectDumpableTable().
◆ table_exclude_patterns
|
static |
◆ table_exclude_patterns_and_children
|
static |
◆ table_include_oids
|
static |
Definition at line 174 of file pg_dump.c.
Referenced by main(), processExtensionTables(), selectDumpableNamespace(), and selectDumpableTable().
◆ table_include_patterns
|
static |
◆ table_include_patterns_and_children
|
static |
◆ tabledata_exclude_oids
|
static |
◆ tabledata_exclude_patterns
|
static |
◆ tabledata_exclude_patterns_and_children
|
static |
