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 236 of file pg_dump.c.
418{
422 TableInfo *tblinfo;
429 RestoreOptions *ropt;
435 int numWorkers = 1;
439 pg_compress_specification compression_spec = {0};
452
454
488
489 /*
490 * the following options don't have an equivalent short option letter
491 */
537
539 };
540
541 pg_logging_init(argv[0]);
544
545 /*
546 * Initialize what we need for parallel execution, especially for thread
547 * support on Windows.
548 */
549 init_parallel_dump_utils();
550
552
553 if (argc > 1)
554 {
556 {
558 exit_nicely(0);
559 }
561 {
563 exit_nicely(0);
564 }
565 }
566
567 InitDumpOptions(&dopt);
568
571 {
573 {
574 case 'a': /* Dump data only */
576 break;
577
578 case 'b': /* Dump LOs */
580 break;
581
582 case 'B': /* Don't dump LOs */
584 break;
585
586 case 'c': /* clean (i.e., drop) schema prior to create */
587 dopt.outputClean = 1;
588 break;
589
590 case 'C': /* Create DB */
591 dopt.outputCreateDB = 1;
592 break;
593
594 case 'd': /* database name */
596 break;
597
598 case 'e': /* include extension(s) */
601 break;
602
603 case 'E': /* Dump encoding */
605 break;
606
607 case 'f':
609 break;
610
611 case 'F':
613 break;
614
615 case 'h': /* server host */
617 break;
618
619 case 'j': /* number of dump jobs */
621 PG_MAX_JOBS,
622 &numWorkers))
623 exit_nicely(1);
624 break;
625
626 case 'n': /* include schema(s) */
629 break;
630
631 case 'N': /* exclude schema(s) */
633 break;
634
635 case 'O': /* Don't reconnect to match owner */
636 dopt.outputNoOwner = 1;
637 break;
638
639 case 'p': /* server port */
641 break;
642
643 case 'R':
644 /* no-op, still accepted for backwards compatibility */
645 break;
646
647 case 's': /* dump schema only */
649 break;
650
651 case 'S': /* Username for superuser in plain text output */
653 break;
654
655 case 't': /* include table(s) */
658 break;
659
660 case 'T': /* exclude table(s) */
662 break;
663
664 case 'U':
666 break;
667
668 case 'v': /* verbose */
671 break;
672
673 case 'w':
675 break;
676
677 case 'W':
679 break;
680
681 case 'x': /* skip ACL dump */
683 break;
684
685 case 'Z': /* Compression */
687 &compression_detail);
689 break;
690
691 case 0:
692 /* This covers the long options. */
693 break;
694
695 case 2: /* lock-wait-timeout */
697 break;
698
699 case 3: /* SET ROLE */
701 break;
702
703 case 4: /* exclude table(s) data */
705 break;
706
707 case 5: /* section */
709 break;
710
711 case 6: /* snapshot */
713 break;
714
715 case 7: /* no-sync */
717 break;
718
719 case 8:
722 &extra_float_digits))
723 exit_nicely(1);
724 break;
725
726 case 9: /* inserts */
727
728 /*
729 * dump_inserts also stores --rows-per-insert, careful not to
730 * overwrite that.
731 */
734 break;
735
736 case 10: /* rows per insert */
738 &dopt.dump_inserts))
739 exit_nicely(1);
740 break;
741
742 case 11: /* include foreign data */
744 optarg);
745 break;
746
747 case 12: /* include table(s) and their children */
749 optarg);
751 break;
752
753 case 13: /* exclude table(s) and their children */
755 optarg);
756 break;
757
758 case 14: /* exclude data of table(s) and children */
760 optarg);
761 break;
762
763 case 15:
765 exit_nicely(1);
766 break;
767
768 case 16: /* read object filters from file */
770 break;
771
772 case 17: /* exclude extension(s) */
774 optarg);
775 break;
776
777 case 18:
779 break;
780
781 case 19:
783 break;
784
785 case 20:
787 break;
788
789 case 21:
791 break;
792
793 case 22:
795 break;
796
797 case 25:
799 break;
800
801 default:
802 /* getopt_long already emitted a complaint */
804 exit_nicely(1);
805 }
806 }
807
808 /*
809 * Non-option argument specifies database name as long as it wasn't
810 * already specified with -d / --dbname
811 */
814
815 /* Complain if any arguments remain */
817 {
819 argv[optind]);
821 exit_nicely(1);
822 }
823
824 /* --column-inserts implies --inserts */
827
828 /* *-only options are incompatible with each other */
832
833 /* --no-* and *-only for same thing are incompatible */
840
841 /* --statistics and --no-statistics are incompatible */
844
845 /* --statistics is incompatible with *-only (except --statistics-only) */
849
850 /* --include-foreign-data is incompatible with --schema-only */
853
856 "--include-foreign-data");
857
858 /* --clean is incompatible with --data-only */
861
864 "--if-exists", "-c/--clean");
865
866 /*
867 * Set derivative flags. Ambiguous or nonsensical combinations, e.g.
868 * "--schema-only --no-schema", will have already caused an error in one
869 * of the checks above.
870 */
877
878
879 /*
880 * --inserts are already implied above if --column-inserts or
881 * --rows-per-insert were specified.
882 */
885 "--on-conflict-do-nothing",
886 "--inserts", "--rows-per-insert", "--column-inserts");
887
888 /* Identify archive format to emit */
890
891 /* archiveFormat specific setup */
893 {
894 plainText = 1;
895
896 /*
897 * If you don't provide a restrict key, one will be appointed for you.
898 */
905 }
908 "--restrict-key", "--format=plain");
909
910 /*
911 * Custom and directory formats are compressed by default with gzip when
912 * available, not the others. If gzip is not available, no compression is
913 * done by default.
914 */
916 !user_compression_defined)
917 {
918#ifdef HAVE_LIBZ
920#else
922#endif
923 }
924
925 /*
926 * Compression options
927 */
929 &compression_algorithm))
932
934 &compression_spec);
938 error_detail);
939
943
944 /*
945 * Disable support for zstd workers for now - these are based on
946 * threading, and it's unclear how it interacts with parallel dumps on
947 * platforms where that relies on threads too (e.g. Windows).
948 */
951 "workers");
952
953 /*
954 * If emitting an archive format, we always want to emit a DATABASE item,
955 * in case --create is specified at pg_restore time.
956 */
958 dopt.outputCreateDB = 1;
959
960 /* Parallel backup only in the directory archive format so far */
963
964 /* Open the output file */
967
968 /* Make dump options accessible right away */
970
971 /* Register the cleanup hook */
973
974 /* Let the archiver know how noisy to be */
976
977
978 /*
979 * We allow the server to be back to 9.2, and up to any minor release of
980 * our own major version. (See also version check in pg_dumpall.c.)
981 */
984
986
987 /*
988 * Open the database using the Archiver, so it knows about it. Errors mean
989 * death.
990 */
993
994 /*
995 * On hot standbys, never try to dump unlogged table data, since it will
996 * just throw an error.
997 */
1000
1001 /*
1002 * Find the last built-in OID, if needed (prior to 8.1)
1003 *
1004 * With 8.1 and above, we can just use FirstNormalObjectId - 1.
1005 */
1007
1009
1010 /* Expand schema selection patterns into OID lists */
1012 {
1014 &schema_include_oids,
1015 strict_names);
1018 }
1020 &schema_exclude_oids,
1021 false);
1022 /* non-matching exclusion patterns aren't an error */
1023
1024 /* Expand table selection patterns into OID lists */
1026 &table_include_oids,
1029 &table_include_oids,
1035
1037 &table_exclude_oids,
1038 false, false);
1040 &table_exclude_oids,
1041 false, true);
1042
1044 &tabledata_exclude_oids,
1045 false, false);
1047 &tabledata_exclude_oids,
1048 false, true);
1049
1051 &foreign_servers_include_oids);
1052
1053 /* non-matching exclusion patterns aren't an error */
1054
1055 /* Expand extension selection patterns into OID lists */
1057 {
1059 &extension_include_oids,
1060 strict_names);
1063 }
1065 &extension_exclude_oids,
1066 false);
1067 /* non-matching exclusion patterns aren't an error */
1068
1069 /*
1070 * Dumping LOs is the default for dumps where an inclusion switch is not
1071 * used (an "include everything" dump). -B can be used to exclude LOs
1072 * from those dumps. -b can be used to include LOs even when an inclusion
1073 * switch is used.
1074 *
1075 * -s means "schema only" and LOs are data, not schema, so we never
1076 * include LOs when -s is used.
1077 */
1080
1081 /*
1082 * Collect role names so we can map object owner OIDs to names.
1083 */
1085
1086 /*
1087 * Now scan the database and create DumpableObject structs for all the
1088 * objects we intend to dump.
1089 */
1091
1093 {
1097 getTableDataFKConstraints();
1098 }
1099
1102
1103 /*
1104 * For binary upgrade mode, dump the pg_shdepend rows for large objects
1105 * and maybe even pg_largeobject_metadata (see comment below for details).
1106 * This is faster to restore than the equivalent set of large object
1107 * commands.
1108 */
1110 {
1112
1115
1116 /*
1117 * Only dump large object shdepend rows for this database.
1118 */
1120 "AND dbid = (SELECT oid FROM pg_database "
1121 " WHERE datname = current_database())";
1122
1123 /*
1124 * For binary upgrades from v16 and newer versions, we can copy
1125 * pg_largeobject_metadata's files from the old cluster, so we don't
1126 * need to dump its contents. pg_upgrade can't copy/link the files
1127 * from older versions because aclitem (needed by
1128 * pg_largeobject_metadata.lomacl) changed its storage format in v16.
1129 */
1131 {
1133
1136 }
1137 }
1138
1139 /*
1140 * In binary-upgrade mode, we do not have to worry about the actual LO
1141 * data or the associated metadata that resides in the pg_largeobject and
1142 * pg_largeobject_metadata tables, respectively.
1143 *
1144 * However, we do need to collect LO information as there may be comments
1145 * or other information on LOs that we do need to dump out.
1146 */
1149
1150 /*
1151 * Collect dependency data to assist in ordering the objects.
1152 */
1154
1155 /*
1156 * Collect ACLs, comments, and security labels, if wanted.
1157 */
1164
1165 /* For binary upgrade mode, collect required pg_class information. */
1168
1169 /* Collect sequence information. */
1171
1172 /* Lastly, create dummy objects to represent the section boundaries */
1174
1175 /* Get pointers to all the known DumpableObjects */
1177
1178 /*
1179 * Add dummy dependencies to enforce the dump section ordering.
1180 */
1182
1183 /*
1184 * Sort the objects into a safe dump order (no forward references).
1185 *
1186 * We rely on dependency information to help us determine a safe order, so
1187 * the initial sort is mostly for cosmetic purposes: we sort by name to
1188 * ensure that logically identical schemas will dump identically.
1189 */
1191
1194
1195 /*
1196 * Create archive TOC entries for all the objects to be dumped, in a safe
1197 * order.
1198 */
1199
1200 /*
1201 * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
1202 */
1206
1207 /* The database items are always next, unless we don't want them at all */
1210
1211 /* Now the rearrangeable objects. */
1214
1215 /*
1216 * Set up options info to ensure we dump what we want.
1217 */
1218 ropt = NewRestoreOptions();
1220
1221 /* if you change this list, see dumpOptionsFromRestoreOptions */
1255
1256 ropt->compression_spec = compression_spec;
1257
1259
1261
1262 /* Mark which entries should be output */
1264
1265 /*
1266 * The archive's TOC entries are now marked as to which ones will actually
1267 * be output, so we can set up their dependency lists properly. This isn't
1268 * necessary for plain-text output, though.
1269 */
1272
1273 /*
1274 * And finally we can do the actual output.
1275 *
1276 * Note: for non-plain-text output formats, the output file is written
1277 * inside CloseArchive(). This is, um, bizarre; but not worth changing
1278 * right now.
1279 */
1282
1284
1285 exit_nicely(0);
1286}
1287
1288
1289static void
1291{
1292 printf(_("%s exports a PostgreSQL database as an SQL script or to other formats.\n\n"), progname);
1295
1299 " plain text (default))\n"));
1304 " compress as specified\n"));
1309
1323 " plain-text format\n"));
1334 " access to)\n"));
1337 " do NOT dump the specified table(s), including\n"
1338 " child and partition tables\n"));
1341 " do NOT dump data for the specified table(s),\n"
1342 " including child and partition tables\n"));
1345 " based on expressions in FILENAME\n"));
1348 " include data of foreign tables on foreign\n"
1349 " servers matching PATTERN\n"));
1375 " match at least one entity each\n"));
1377 " child and partition tables\n"));
1379 " use SET SESSION AUTHORIZATION commands instead of\n"
1380 " ALTER OWNER commands to set ownership\n"));
1381
1390
1392 "variable value is used.\n\n"));
1395}
1396
1397static void
1400{
1403
1405
1406 /*
1407 * Set the client encoding if requested.
1408 */
1410 {
1413 dumpencoding);
1414 }
1415
1416 /*
1417 * Force standard_conforming_strings on, just in case we are dumping from
1418 * an old server that has it disabled. Without this, literals in views,
1419 * expressions, etc, would be incorrect for modern servers.
1420 */
1422
1423 /*
1424 * And reflect that to AH->std_strings. You might think that we should
1425 * just delete that variable and the code that checks it, but that would
1426 * be problematic for pg_restore, which at least for now should still cope
1427 * with archives containing the other setting (cf. processStdStringsEntry
1428 * in pg_backup_archiver.c).
1429 */
1431
1432 /*
1433 * Get the active encoding, so we know how to escape strings.
1434 */
1437
1438 /*
1439 * Set the role if requested. In a parallel dump worker, we'll be passed
1440 * use_role == NULL, but AH->use_role is already set (if user specified it
1441 * originally) and we should use that.
1442 */
1444 use_role = AH->use_role;
1445
1446 /* Set the role if requested */
1447 if (use_role)
1448 {
1450
1453 destroyPQExpBuffer(query);
1454
1455 /* save it for possible later use by parallel workers */
1458 }
1459
1460 /* Set the datestyle to ISO to ensure the dump's portability */
1462
1463 /* Likewise, avoid using sql_standard intervalstyle */
1465
1466 /*
1467 * Use an explicitly specified extra_float_digits if it has been provided.
1468 * Otherwise, set extra_float_digits so that we can dump float data
1469 * exactly (given correctly implemented float I/O code, anyway).
1470 */
1472 {
1474
1476 extra_float_digits);
1478 destroyPQExpBuffer(q);
1479 }
1480 else
1482
1483 /*
1484 * Disable synchronized scanning, to prevent unpredictable changes in row
1485 * ordering across a dump and reload.
1486 */
1488
1489 /*
1490 * Disable timeouts if supported.
1491 */
1499
1500 /*
1501 * Quote all identifiers, if requested.
1502 */
1505
1506 /*
1507 * Adjust row-security mode, if supported.
1508 */
1510 {
1513 else
1515 }
1516
1517 /*
1518 * For security reasons, we restrict the expansion of non-system views and
1519 * access to foreign tables during the pg_dump process. This restriction
1520 * is adjusted when dumping foreign table data.
1521 */
1523
1524 /*
1525 * Initialize prepared-query state to "nothing prepared". We do this here
1526 * so that a parallel dump worker will have its own state.
1527 */
1529
1530 /*
1531 * Start transaction-snapshot mode transaction to dump consistent data.
1532 */
1534
1535 /*
1536 * To support the combination of serializable_deferrable with the jobs
1537 * option we use REPEATABLE READ for the worker connections that are
1538 * passed a snapshot. As long as the snapshot is acquired in a
1539 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1540 * REPEATABLE READ transaction provides the appropriate integrity
1541 * guarantees. This is a kluge, but safe for back-patching.
1542 */
1544 ExecuteSqlStatement(AH,
1545 "SET TRANSACTION ISOLATION LEVEL "
1546 "SERIALIZABLE, READ ONLY, DEFERRABLE");
1547 else
1548 ExecuteSqlStatement(AH,
1549 "SET TRANSACTION ISOLATION LEVEL "
1550 "REPEATABLE READ, READ ONLY");
1551
1552 /*
1553 * If user specified a snapshot to use, select that. In a parallel dump
1554 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1555 * is already set (if the server can handle it) and we should use that.
1556 */
1559
1561 {
1563
1567 destroyPQExpBuffer(query);
1568 }
1570 {
1574 }
1575}
1576
1577/* Set up connection for a parallel worker process */
1578static void
1580{
1581 /*
1582 * We want to re-select all the same values the leader connection is
1583 * using. We'll have inherited directly-usable values in
1584 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1585 * inherited encoding value back to a string to pass to setup_connection.
1586 */
1587 setup_connection(AH,
1589 NULL,
1590 NULL);
1591}
1592
1593static char *
1595{
1596 char *query = "SELECT pg_catalog.pg_export_snapshot()";
1598 PGresult *res;
1599
1602 PQclear(res);
1603
1605}
1606
1609{
1611
1613
1615 {
1616 /* This is used by pg_dumpall, and is not documented */
1619 }
1636 else
1639}
1640
1641/*
1642 * Find the OIDs of all schemas matching the given list of patterns,
1643 * and append them to the given OID list.
1644 */
1645static void
1648 SimpleOidList *oids,
1650{
1651 PQExpBuffer query;
1652 PGresult *res;
1653 SimpleStringListCell *cell;
1655
1657 return; /* nothing to do */
1658
1659 query = createPQExpBuffer();
1660
1661 /*
1662 * The loop below runs multiple SELECTs might sometimes result in
1663 * duplicate entries in the OID list, but we don't care.
1664 */
1665
1667 {
1670
1671 appendPQExpBufferStr(query,
1672 "SELECT oid FROM pg_catalog.pg_namespace n\n");
1676 &dotcnt);
1679 cell->val);
1683
1687
1689 {
1691 }
1692
1693 PQclear(res);
1694 resetPQExpBuffer(query);
1695 }
1696
1697 destroyPQExpBuffer(query);
1698}
1699
1700/*
1701 * Find the OIDs of all extensions matching the given list of patterns,
1702 * and append them to the given OID list.
1703 */
1704static void
1707 SimpleOidList *oids,
1709{
1710 PQExpBuffer query;
1711 PGresult *res;
1712 SimpleStringListCell *cell;
1714
1716 return; /* nothing to do */
1717
1718 query = createPQExpBuffer();
1719
1720 /*
1721 * The loop below runs multiple SELECTs might sometimes result in
1722 * duplicate entries in the OID list, but we don't care.
1723 */
1725 {
1727
1728 appendPQExpBufferStr(query,
1729 "SELECT oid FROM pg_catalog.pg_extension e\n");
1732 &dotcnt);
1735 cell->val);
1736
1740
1742 {
1744 }
1745
1746 PQclear(res);
1747 resetPQExpBuffer(query);
1748 }
1749
1750 destroyPQExpBuffer(query);
1751}
1752
1753/*
1754 * Find the OIDs of all foreign servers matching the given list of patterns,
1755 * and append them to the given OID list.
1756 */
1757static void
1760 SimpleOidList *oids)
1761{
1762 PQExpBuffer query;
1763 PGresult *res;
1764 SimpleStringListCell *cell;
1766
1768 return; /* nothing to do */
1769
1770 query = createPQExpBuffer();
1771
1772 /*
1773 * The loop below runs multiple SELECTs might sometimes result in
1774 * duplicate entries in the OID list, but we don't care.
1775 */
1776
1778 {
1780
1781 appendPQExpBufferStr(query,
1782 "SELECT oid FROM pg_catalog.pg_foreign_server s\n");
1785 &dotcnt);
1788 cell->val);
1789
1793
1796
1797 PQclear(res);
1798 resetPQExpBuffer(query);
1799 }
1800
1801 destroyPQExpBuffer(query);
1802}
1803
1804/*
1805 * Find the OIDs of all tables matching the given list of patterns,
1806 * and append them to the given OID list. See also expand_dbname_patterns()
1807 * in pg_dumpall.c
1808 */
1809static void
1813{
1814 PQExpBuffer query;
1815 PGresult *res;
1816 SimpleStringListCell *cell;
1818
1820 return; /* nothing to do */
1821
1822 query = createPQExpBuffer();
1823
1824 /*
1825 * this might sometimes result in duplicate entries in the OID list, but
1826 * we don't care.
1827 */
1828
1830 {
1833
1834 /*
1835 * Query must remain ABSOLUTELY devoid of unqualified names. This
1836 * would be unnecessary given a pg_table_is_visible() variant taking a
1837 * search_path argument.
1838 *
1839 * For with_child_tables, we start with the basic query's results and
1840 * recursively search the inheritance tree to add child tables.
1841 */
1843 {
1845 }
1846
1847 appendPQExpBuffer(query,
1848 "SELECT c.oid"
1849 "\nFROM pg_catalog.pg_class c"
1850 "\n LEFT JOIN pg_catalog.pg_namespace n"
1851 "\n ON n.oid OPERATOR(pg_catalog.=) c.relnamespace"
1852 "\nWHERE c.relkind OPERATOR(pg_catalog.=) ANY"
1853 "\n (array['%c', '%c', '%c', '%c', '%c', '%c', '%c'])\n",
1861 &dotcnt);
1864 cell->val);
1868
1870 {
1872 "\nSELECT i.inhrelid"
1873 "\nFROM partition_tree p"
1874 "\n JOIN pg_catalog.pg_inherits i"
1875 "\n ON p.relid OPERATOR(pg_catalog.=) i.inhparent"
1876 "\n)"
1877 "\nSELECT relid FROM partition_tree");
1878 }
1879
1883 ALWAYS_SECURE_SEARCH_PATH_SQL));
1886
1888 {
1890 }
1891
1892 PQclear(res);
1893 resetPQExpBuffer(query);
1894 }
1895
1896 destroyPQExpBuffer(query);
1897}
1898
1899/*
1900 * Verifies that the connected database name matches the given database name,
1901 * and if not, dies with an error about the given pattern.
1902 *
1903 * The 'dbname' argument should be a literal name parsed from 'pattern'.
1904 */
1905static void
1907{
1908 const char *db;
1909
1913
1916 pattern);
1917}
1918
1919/*
1920 * checkExtensionMembership
1921 * Determine whether object is an extension member, and if so,
1922 * record an appropriate dependency and set the object's dump flag.
1923 *
1924 * It's important to call this for each object that could be an extension
1925 * member. Generally, we integrate this with determining the object's
1926 * to-be-dumped-ness, since extension membership overrides other rules for that.
1927 *
1928 * Returns true if object is an extension member, else false.
1929 */
1930static bool
1932{
1934
1936 return false;
1937
1939
1940 /* Record dependency so that getDependencies needn't deal with that */
1942
1943 /*
1944 * In 9.6 and above, mark the member object to have any non-initial ACLs
1945 * dumped. (Any initial ACLs will be removed later, using data from
1946 * pg_init_privs, so that we'll dump only the delta from the extension's
1947 * initial setup.)
1948 *
1949 * Prior to 9.6, we do not include any extension member components.
1950 *
1951 * In binary upgrades, we still dump all components of the members
1952 * individually, since the idea is to exactly reproduce the database
1953 * contents rather than replace the extension contents with something
1954 * different.
1955 *
1956 * Note: it might be interesting someday to implement storage and delta
1957 * dumping of extension members' RLS policies and/or security labels.
1958 * However there is a pitfall for RLS policies: trying to dump them
1959 * requires getting a lock on their tables, and the calling user might not
1960 * have privileges for that. We need no lock to examine a table's ACLs,
1961 * so the current feature doesn't have a problem of that sort.
1962 */
1965 else
1966 {
1969 else
1971 }
1972
1973 return true;
1974}
1975
1976/*
1977 * selectDumpableNamespace: policy-setting subroutine
1978 * Mark a namespace as to be dumped or not
1979 */
1980static void
1982{
1983 /*
1984 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
1985 * and (for --clean) a DROP SCHEMA statement. (In the absence of
1986 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
1987 */
1989
1990 /*
1991 * If specific tables are being dumped, do not dump any complete
1992 * namespaces. If specific namespaces are being dumped, dump just those
1993 * namespaces. Otherwise, dump all non-system namespaces.
1994 */
2000 nsinfo->dobj.catId.oid) ?
2004 {
2005 /*
2006 * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
2007 * they are interesting (and not the original ACLs which were set at
2008 * initdb time, see pg_init_privs).
2009 */
2011 }
2014 {
2015 /* Other system schemas don't get dumped */
2017 }
2019 {
2020 /*
2021 * The public schema is a strange beast that sits in a sort of
2022 * no-mans-land between being a system object and a user object.
2023 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
2024 * a comment and an indication of ownership. If the owner is the
2025 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
2026 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
2027 */
2033
2034 /*
2035 * Also, make like it has a comment even if it doesn't; this is so
2036 * that we'll emit a command to drop the comment, if appropriate.
2037 * (Without this, we'd not call dumpCommentExtended for it.)
2038 */
2040 }
2041 else
2043
2044 /*
2045 * In any case, a namespace can be excluded by an exclusion switch
2046 */
2049 nsinfo->dobj.catId.oid))
2051
2052 /*
2053 * If the schema belongs to an extension, allow extension membership to
2054 * override the dump decision for the schema itself. However, this does
2055 * not change dump_contains, so this won't change what we do with objects
2056 * within the schema. (If they belong to the extension, they'll get
2057 * suppressed by it, otherwise not.)
2058 */
2060}
2061
2062/*
2063 * selectDumpableTable: policy-setting subroutine
2064 * Mark a table as to be dumped or not
2065 */
2066static void
2068{
2070 return; /* extension membership overrides all else */
2071
2072 /*
2073 * If specific tables are being dumped, dump just those tables; else, dump
2074 * according to the parent namespace's dump flag.
2075 */
2078 tbinfo->dobj.catId.oid) ?
2080 else
2082
2083 /*
2084 * In any case, a table can be excluded by an exclusion switch
2085 */
2088 tbinfo->dobj.catId.oid))
2090}
2091
2092/*
2093 * selectDumpableType: policy-setting subroutine
2094 * Mark a type as to be dumped or not
2095 *
2096 * If it's a table's rowtype or an autogenerated array type, we also apply a
2097 * special type code to facilitate sorting into the desired order. (We don't
2098 * want to consider those to be ordinary types because that would bring tables
2099 * up into the datatype part of the dump order.) We still set the object's
2100 * dump flag; that's not going to cause the dummy type to be dumped, but we
2101 * need it so that casts involving such types will be dumped correctly -- see
2102 * dumpCast. This means the flag should be set the same as for the underlying
2103 * object (the table or base type).
2104 */
2105static void
2107{
2108 /* skip complex types, except for standalone composite types */
2111 {
2113
2117 else
2119 return;
2120 }
2121
2122 /* skip auto-generated array and multirange types */
2124 {
2126
2127 /*
2128 * Fall through to set the dump flag; we assume that the subsequent
2129 * rules will do the same thing as they would for the array's base
2130 * type or multirange's range type. (We cannot reliably look up the
2131 * base type here, since getTypes may not have processed it yet.)
2132 */
2133 }
2134
2136 return; /* extension membership overrides all else */
2137
2138 /* Dump based on if the contents of the namespace are being dumped */
2140}
2141
2142/*
2143 * selectDumpableDefaultACL: policy-setting subroutine
2144 * Mark a default ACL as to be dumped or not
2145 *
2146 * For per-schema default ACLs, dump if the schema is to be dumped.
2147 * Otherwise dump if we are dumping "everything". Note that dumpSchema
2148 * and aclsSkip are checked separately.
2149 */
2150static void
2152{
2153 /* Default ACLs can't be extension members */
2154
2156 /* default ACLs are considered part of the namespace */
2158 else
2161}
2162
2163/*
2164 * selectDumpableCast: policy-setting subroutine
2165 * Mark a cast as to be dumped or not
2166 *
2167 * Casts do not belong to any particular namespace (since they haven't got
2168 * names), nor do they have identifiable owners. To distinguish user-defined
2169 * casts from built-in ones, we must resort to checking whether the cast's
2170 * OID is in the range reserved for initdb.
2171 */
2172static void
2174{
2176 return; /* extension membership overrides all else */
2177
2178 /*
2179 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
2180 * support ACLs currently.
2181 */
2184 else
2187}
2188
2189/*
2190 * selectDumpableProcLang: policy-setting subroutine
2191 * Mark a procedural language as to be dumped or not
2192 *
2193 * Procedural languages do not belong to any particular namespace. To
2194 * identify built-in languages, we must resort to checking whether the
2195 * language's OID is in the range reserved for initdb.
2196 */
2197static void
2199{
2201 return; /* extension membership overrides all else */
2202
2203 /*
2204 * Only include procedural languages when we are dumping everything.
2205 *
2206 * For from-initdb procedural languages, only include ACLs, as we do for
2207 * the pg_catalog namespace. We need this because procedural languages do
2208 * not live in any namespace.
2209 */
2212 else
2213 {
2217 else
2219 }
2220}
2221
2222/*
2223 * selectDumpableAccessMethod: policy-setting subroutine
2224 * Mark an access method as to be dumped or not
2225 *
2226 * Access methods do not belong to any particular namespace. To identify
2227 * built-in access methods, we must resort to checking whether the
2228 * method's OID is in the range reserved for initdb.
2229 */
2230static void
2232{
2233 /* see getAccessMethods() comment about v9.6. */
2235 {
2237 return;
2238 }
2239
2241 return; /* extension membership overrides all else */
2242
2243 /*
2244 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
2245 * they do not support ACLs currently.
2246 */
2249 else
2252}
2253
2254/*
2255 * selectDumpableExtension: policy-setting subroutine
2256 * Mark an extension as to be dumped or not
2257 *
2258 * Built-in extensions should be skipped except for checking ACLs, since we
2259 * assume those will already be installed in the target database. We identify
2260 * such extensions by their having OIDs in the range reserved for initdb.
2261 * We dump all user-added extensions by default. No extensions are dumped
2262 * if include_everything is false (i.e., a --schema or --table switch was
2263 * given), except if --extension specifies a list of extensions to dump.
2264 */
2265static void
2267{
2268 /*
2269 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2270 * change permissions on their member objects, if they wish to, and have
2271 * those changes preserved.
2272 */
2275 else
2276 {
2277 /* check if there is a list of extensions to dump */
2281 extinfo->dobj.catId.oid) ?
2283 else
2285 dopt->include_everything ?
2287
2288 /* check that the extension is not explicitly excluded */
2291 extinfo->dobj.catId.oid))
2293 }
2294}
2295
2296/*
2297 * selectDumpablePublicationObject: policy-setting subroutine
2298 * Mark a publication object as to be dumped or not
2299 *
2300 * A publication can have schemas and tables which have schemas, but those are
2301 * ignored in decision making, because publications are only dumped when we are
2302 * dumping everything.
2303 */
2304static void
2306{
2308 return; /* extension membership overrides all else */
2309
2312}
2313
2314/*
2315 * selectDumpableStatisticsObject: policy-setting subroutine
2316 * Mark an extended statistics object as to be dumped or not
2317 *
2318 * We dump an extended statistics object if the schema it's in and the table
2319 * it's for are being dumped. (This'll need more thought if statistics
2320 * objects ever support cross-table stats.)
2321 */
2322static void
2324{
2326 return; /* extension membership overrides all else */
2327
2332}
2333
2334/*
2335 * selectDumpableObject: policy-setting subroutine
2336 * Mark a generic dumpable object as to be dumped or not
2337 *
2338 * Use this only for object types without a special-case routine above.
2339 */
2340static void
2342{
2344 return; /* extension membership overrides all else */
2345
2346 /*
2347 * Default policy is to dump if parent namespace is dumpable, or for
2348 * non-namespace-associated items, dump if we're dumping "everything".
2349 */
2350 if (dobj->namespace)
2352 else
2355}
2356
2357/*
2358 * Dump a table's contents for loading using the COPY command
2359 * - this routine is called by the Archiver when it wants the table
2360 * to be dumped.
2361 */
2362static int
2364{
2369
2370 /*
2371 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2372 * which uses it already.
2373 */
2376 PGresult *res;
2377 int ret;
2380
2382 tbinfo->dobj.namespace->dobj.name, classname);
2383
2384 /*
2385 * Specify the column list explicitly so that we have no possibility of
2386 * retrieving data in the wrong column order. (The default column
2387 * ordering of COPY will not be what we want in certain corner cases
2388 * involving ADD COLUMN and inheritance.)
2389 */
2391
2392 /*
2393 * Use COPY (SELECT ...) TO when dumping a foreign table's data, when a
2394 * filter condition was specified, and when in binary upgrade mode and
2395 * dumping an old pg_largeobject_metadata defined WITH OIDS. For other
2396 * cases a simple COPY suffices.
2397 */
2401 {
2402 /* Temporary allows to access to foreign tables to dump data */
2405
2407 /* klugery to get rid of parens in column list */
2409 {
2412 }
2413 else
2415
2419 }
2420 else
2421 {
2424 column_list);
2425 }
2427 PQclear(res);
2429
2430 for (;;)
2431 {
2433
2434 if (ret < 0)
2435 break; /* done or error */
2436
2438 {
2441 }
2442
2443 /* ----------
2444 * THROTTLE:
2445 *
2446 * There was considerable discussion in late July, 2000 regarding
2447 * slowing down pg_dump when backing up large tables. Users with both
2448 * slow & fast (multi-processor) machines experienced performance
2449 * degradation when doing a backup.
2450 *
2451 * Initial attempts based on sleeping for a number of ms for each ms
2452 * of work were deemed too complex, then a simple 'sleep in each loop'
2453 * implementation was suggested. The latter failed because the loop
2454 * was too tight. Finally, the following was implemented:
2455 *
2456 * If throttle is non-zero, then
2457 * See how long since the last sleep.
2458 * Work out how long to sleep (based on ratio).
2459 * If sleep is more than 100ms, then
2460 * sleep
2461 * reset timer
2462 * EndIf
2463 * EndIf
2464 *
2465 * where the throttle value was the number of ms to sleep per ms of
2466 * work. The calculation was done in each loop.
2467 *
2468 * Most of the hard work is done in the backend, and this solution
2469 * still did not work particularly well: on slow machines, the ratio
2470 * was 50:1, and on medium paced machines, 1:1, and on fast
2471 * multi-processor machines, it had little or no effect, for reasons
2472 * that were unclear.
2473 *
2474 * Further discussion ensued, and the proposal was dropped.
2475 *
2476 * For those people who want this feature, it can be implemented using
2477 * gettimeofday in each loop, calculating the time since last sleep,
2478 * multiplying that by the sleep ratio, then if the result is more
2479 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2480 * function to sleep for a subsecond period ie.
2481 *
2482 * select(0, NULL, NULL, NULL, &tvi);
2483 *
2484 * This will return after the interval specified in the structure tvi.
2485 * Finally, call gettimeofday again to save the 'last sleep time'.
2486 * ----------
2487 */
2488 }
2490
2491 if (ret == -2)
2492 {
2493 /* copy data transfer failed */
2494 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2497 exit_nicely(1);
2498 }
2499
2500 /* Check command status and return to normal libpq state */
2503 {
2507 exit_nicely(1);
2508 }
2509 PQclear(res);
2510
2511 /* Do this to ensure we've pumped libpq back to idle state */
2514 classname);
2515
2516 destroyPQExpBuffer(q);
2517
2518 /* Revert back the setting */
2521
2522 return 1;
2523}
2524
2525/*
2526 * Dump table data using INSERT commands.
2527 *
2528 * Caution: when we restore from an archive file direct to database, the
2529 * INSERT commands emitted by this function have to be parsed by
2530 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
2531 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
2532 */
2533static int
2535{
2541 char *attgenerated;
2542 PGresult *res;
2543 int nfields,
2544 i;
2547
2548 /* Temporary allows to access to foreign tables to dump data */
2551
2552 /*
2553 * If we're going to emit INSERTs with column names, the most efficient
2554 * way to deal with generated columns is to exclude them entirely. For
2555 * INSERTs without column names, we have to emit DEFAULT rather than the
2556 * actual column value --- but we can save a few cycles by fetching nulls
2557 * rather than the uninteresting-to-us value.
2558 */
2561 nfields = 0;
2563 {
2565 continue;
2567 continue;
2568 if (nfields > 0)
2572 else
2575 nfields++;
2576 }
2577 /* Servers before 9.4 will complain about zero-column SELECT */
2578 if (nfields == 0)
2584
2586
2587 while (1)
2588 {
2590 PGRES_TUPLES_OK);
2591
2592 /* cross-check field count, allowing for dummy NULL if any */
2594 !(nfields == 0 && PQnfields(res) == 1))
2596 tbinfo->dobj.name);
2597
2598 /*
2599 * First time through, we build as much of the INSERT statement as
2600 * possible in "insertStmt", which we can then just print for each
2601 * statement. If the table happens to have zero dumpable columns then
2602 * this will be a complete statement, otherwise it will end in
2603 * "VALUES" and be ready to have the row's column values printed.
2604 */
2606 {
2608
2610
2611 /*
2612 * When load-via-partition-root is set or forced, get the root
2613 * table name for the partition table, so that we can reload data
2614 * through the root table.
2615 */
2617 (dopt->load_via_partition_root ||
2620 else
2622
2625
2626 /* corner case for zero-column table */
2627 if (nfields == 0)
2628 {
2630 }
2631 else
2632 {
2633 /* append the list of column names if required */
2635 {
2637 for (int field = 0; field < nfields; field++)
2638 {
2639 if (field > 0)
2643 }
2645 }
2646
2649
2651 }
2652 }
2653
2655 {
2656 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2659
2660 /*
2661 * If it is zero-column table then we've already written the
2662 * complete statement, which will mean we've disobeyed
2663 * --rows-per-insert when it's set greater than 1. We do support
2664 * a way to make this multi-row with: SELECT UNION ALL SELECT
2665 * UNION ALL ... but that's non-standard so we should avoid it
2666 * given that using INSERTs is mostly only ever needed for
2667 * cross-database exports.
2668 */
2669 if (nfields == 0)
2670 continue;
2671
2672 /* Emit a row heading */
2677 else
2679
2680 for (int field = 0; field < nfields; field++)
2681 {
2682 if (field > 0)
2684 if (attgenerated[field])
2685 {
2687 continue;
2688 }
2690 {
2692 continue;
2693 }
2694
2695 /* XXX This code is partially duplicated in ruleutils.c */
2697 {
2705 {
2706 /*
2707 * These types are printed without quotes unless
2708 * they contain values that aren't accepted by the
2709 * scanner unquoted (e.g., 'NaN'). Note that
2710 * strtod() and friends might accept NaN, so we
2711 * can't use that to test.
2712 *
2713 * In reality we only need to defend against
2714 * infinity and NaN, so we need not get too crazy
2715 * about pattern matching here.
2716 */
2718
2721 else
2723 }
2724 break;
2725
2729 PQgetvalue(res, tuple, field));
2730 break;
2731
2735 else
2737 break;
2738
2739 default:
2740 /* All other types are printed as string literals. */
2741 resetPQExpBuffer(q);
2742 appendStringLiteralAH(q,
2743 PQgetvalue(res, tuple, field),
2744 fout);
2746 break;
2747 }
2748 }
2749
2750 /* Terminate the row ... */
2752
2753 /* ... and the statement, if the target no. of rows is reached */
2755 {
2758 else
2760 /* Reset the row counter */
2761 rows_this_statement = 0;
2762 }
2763 }
2764
2766 {
2767 PQclear(res);
2768 break;
2769 }
2770 PQclear(res);
2771 }
2772
2773 /* Terminate any statements that didn't make the row count. */
2775 {
2778 else
2780 }
2781
2783
2785
2786 destroyPQExpBuffer(q);
2789 free(attgenerated);
2790
2791 /* Revert back the setting */
2794
2795 return 1;
2796}
2797
2798/*
2799 * getRootTableInfo:
2800 * get the root TableInfo for the given partition table.
2801 */
2804{
2806
2809
2812 {
2815 }
2816
2818}
2819
2820/*
2821 * forcePartitionRootLoad
2822 * Check if we must force load_via_partition_root for this partition.
2823 *
2824 * This is required if any level of ancestral partitioned table has an
2825 * unsafe partitioning scheme.
2826 */
2827static bool
2829{
2831
2834
2837 return true;
2839 {
2843 return true;
2844 }
2845
2846 return false;
2847}
2848
2849/*
2850 * dumpTableData -
2851 * dump the contents of a single table
2852 *
2853 * Actually, this just makes an ArchiveEntry for the table contents.
2854 */
2855static void
2857{
2862 DataDumperPtr dumpFn;
2864 char *copyStmt;
2866
2867 /* We had better have loaded per-column details about this table */
2869
2870 /*
2871 * When load-via-partition-root is set or forced, get the root table name
2872 * for the partition table, so that we can reload data through the root
2873 * table. Then construct a comment to be inserted into the TOC entry's
2874 * defn field, so that such cases can be identified reliably.
2875 */
2877 (dopt->load_via_partition_root ||
2879 {
2882
2887 sanitized);
2890 }
2891 else
2893
2895 {
2896 /* Dump/restore using COPY */
2897 dumpFn = dumpTableData_copy;
2898 /* must use 2 steps here 'cause fmtId is nonreentrant */
2900 copyFrom);
2903 copyStmt = copyBuf->data;
2904 }
2905 else
2906 {
2907 /* Restore using INSERT */
2908 dumpFn = dumpTableData_insert;
2909 copyStmt = NULL;
2910 }
2911
2912 /*
2913 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2914 * dependency on its table as "special" and pass it to ArchiveEntry now.
2915 * See comments for BuildArchiveDependencies.
2916 */
2918 {
2919 TocEntry *te;
2920
2923 .namespace = tbinfo->dobj.namespace->dobj.name,
2924 .owner = tbinfo->rolname,
2925 .description = "TABLE DATA",
2926 .section = SECTION_DATA,
2927 .createStmt = tdDefn,
2928 .copyStmt = copyStmt,
2929 .deps = &(tbinfo->dobj.dumpId),
2930 .nDeps = 1,
2931 .dumpFn = dumpFn,
2932 .dumpArg = tdinfo));
2933
2934 /*
2935 * Set the TocEntry's dataLength in case we are doing a parallel dump
2936 * and want to order dump jobs by table size. We choose to measure
2937 * dataLength in table pages (including TOAST pages) during dump, so
2938 * no scaling is needed.
2939 *
2940 * However, relpages is declared as "integer" in pg_class, and hence
2941 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2942 * Cast so that we get the right interpretation of table sizes
2943 * exceeding INT_MAX pages.
2944 */
2947
2948 /*
2949 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2950 * and instead we'd better worry about integer overflow. Clamp to
2951 * INT_MAX if the correct result exceeds that.
2952 */
2953 if (sizeof(te->dataLength) == 4 &&
2955 te->dataLength < 0))
2956 te->dataLength = INT_MAX;
2957 }
2958
2961}
2962
2963/*
2964 * refreshMatViewData -
2965 * load or refresh the contents of a single materialized view
2966 *
2967 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2968 * statement.
2969 */
2970static void
2972{
2974 PQExpBuffer q;
2975
2976 /* If the materialized view is not flagged as populated, skip this. */
2978 return;
2979
2980 q = createPQExpBuffer();
2981
2984
2990 .namespace = tbinfo->dobj.namespace->dobj.name,
2991 .owner = tbinfo->rolname,
2992 .description = "MATERIALIZED VIEW DATA",
2993 .section = SECTION_POST_DATA,
2994 .createStmt = q->data,
2995 .deps = tdinfo->dobj.dependencies,
2996 .nDeps = tdinfo->dobj.nDeps));
2997
2998 destroyPQExpBuffer(q);
2999}
3000
3001/*
3002 * getTableData -
3003 * set up dumpable objects representing the contents of tables
3004 */
3005static void
3007{
3009
3011 {
3013 (!relkind || tblinfo[i].relkind == relkind))
3015 }
3016}
3017
3018/*
3019 * Make a dumpable object for the data of this specific table
3020 *
3021 * Note: we make a TableDataInfo if and only if we are going to dump the
3022 * table data; the "dump" field in such objects isn't very interesting.
3023 */
3024static void
3026{
3028
3029 /*
3030 * Nothing to do if we already decided to dump the table. This will
3031 * happen for "config" tables.
3032 */
3034 return;
3035
3036 /* Skip property graphs (no data to dump) */
3038 return;
3039 /* Skip VIEWs (no data to dump) */
3041 return;
3042 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
3046 tbinfo->foreign_server)))
3047 return;
3048 /* Skip partitioned tables (data in partitions) */
3050 return;
3051
3052 /* Don't dump data in unlogged tables, if so requested */
3054 dopt->no_unlogged_table_data)
3055 return;
3056
3057 /* Check that the data is not explicitly excluded */
3059 tbinfo->dobj.catId.oid))
3060 return;
3061
3062 /* OK, let's dump it */
3064
3069 else
3071
3072 /*
3073 * Note: use tableoid 0 so that this object won't be mistaken for
3074 * something that pg_depend entries apply to.
3075 */
3076 tdinfo->dobj.catId.tableoid = 0;
3084
3085 /* A TableDataInfo contains data, of course */
3087
3089
3090 /*
3091 * Materialized view statistics must be restored after the data, because
3092 * REFRESH MATERIALIZED VIEW replaces the storage and resets the stats.
3093 *
3094 * The dependency is added here because the statistics objects are created
3095 * first.
3096 */
3098 {
3101 }
3102
3103 /* Make sure that we'll collect per-column info for this table. */
3105}
3106
3107/*
3108 * The refresh for a materialized view must be dependent on the refresh for
3109 * any materialized view that this one is dependent on.
3110 *
3111 * This must be called after all the objects are created, but before they are
3112 * sorted.
3113 */
3114static void
3116{
3117 PQExpBuffer query;
3118 PGresult *res;
3119 int ntups,
3120 i;
3122 i_objid,
3123 i_refobjid;
3124
3125 /* No Mat Views before 9.3. */
3127 return;
3128
3129 query = createPQExpBuffer();
3130
3132 "( "
3133 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3134 "FROM pg_depend d1 "
3135 "JOIN pg_class c1 ON c1.oid = d1.objid "
3137 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3138 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3139 "AND d2.objid = r1.oid "
3140 "AND d2.refobjid <> d1.objid "
3141 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3144 "WHERE d1.classid = 'pg_class'::regclass "
3145 "UNION "
3146 "SELECT w.objid, d3.refobjid, c3.relkind "
3147 "FROM w "
3148 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3149 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3150 "AND d3.objid = r3.oid "
3151 "AND d3.refobjid <> w.refobjid "
3152 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3155 ") "
3156 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3157 "FROM w "
3159
3161
3162 ntups = PQntuples(res);
3163
3167
3169 {
3170 CatalogId objId;
3172 DumpableObject *dobj;
3176
3181
3182 dobj = findObjectByCatalogId(objId);
3184 continue;
3185
3191 continue;
3193
3196 continue;
3197
3203 continue;
3205
3207
3210 }
3211
3212 PQclear(res);
3213
3214 destroyPQExpBuffer(query);
3215}
3216
3217/*
3218 * getTableDataFKConstraints -
3219 * add dump-order dependencies reflecting foreign key constraints
3220 *
3221 * This code is executed only in a data-only dump --- in schema+data dumps
3222 * we handle foreign key issues by not creating the FK constraints until
3223 * after the data is loaded. In a data-only dump, however, we want to
3224 * order the table data objects in such a way that a table's referenced
3225 * tables are restored first. (In the presence of circular references or
3226 * self-references this may be impossible; we'll detect and complain about
3227 * that during the dependency sorting step.)
3228 */
3229static void
3231{
3235
3236 /* Search through all the dumpable objects for FK constraints */
3239 {
3241 {
3244
3245 /* Not interesting unless both tables are to be dumped */
3248 continue;
3252 continue;
3253
3254 /*
3255 * Okay, make referencing table's TABLE_DATA object depend on the
3256 * referenced table's TABLE_DATA object.
3257 */
3259 ftable->dataObj->dobj.dumpId);
3260 }
3261 }
3263}
3264
3265
3266/*
3267 * dumpDatabase:
3268 * dump the database definition
3269 */
3270static void
3272{
3279 PGresult *res;
3281 i_oid,
3282 i_datname,
3283 i_datdba,
3284 i_encoding,
3285 i_datlocprovider,
3286 i_collate,
3287 i_ctype,
3288 i_datlocale,
3289 i_daticurules,
3290 i_frozenxid,
3291 i_minmxid,
3292 i_datacl,
3293 i_acldefault,
3294 i_datistemplate,
3295 i_datconnlimit,
3296 i_datcollversion,
3297 i_tablespace;
3302 *dba,
3303 *encoding,
3304 *datlocprovider,
3305 *collate,
3306 *ctype,
3307 *locale,
3308 *icurules,
3309 *datistemplate,
3310 *datconnlimit,
3311 *tablespace;
3312 uint32 frozenxid,
3313 minmxid;
3315
3317
3318 /*
3319 * Fetch the database-level properties for this database.
3320 */
3322 "datdba, "
3323 "pg_encoding_to_char(encoding) AS encoding, "
3324 "datcollate, datctype, datfrozenxid, "
3325 "datacl, acldefault('d', datdba) AS acldefault, "
3326 "datistemplate, datconnlimit, ");
3329 else
3335 else
3336 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
3339 else
3342 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3343 "shobj_description(oid, 'pg_database') AS description "
3344 "FROM pg_database "
3345 "WHERE datname = current_database()");
3346
3348
3367
3378 else
3379 locale = NULL;
3382 else
3391
3393
3394 /*
3395 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3396 * to preserve that), as well as the encoding, locale, and tablespace
3397 * since those can't be altered later. Other DB properties are left to
3398 * the DATABASE PROPERTIES entry, so that they can be applied after
3399 * reconnecting to the target DB.
3400 *
3401 * For binary upgrade, we use the FILE_COPY strategy because testing has
3402 * shown it to be faster. When the server is in binary upgrade mode, it
3403 * will also skip the checkpoints this strategy ordinarily performs.
3404 */
3406 {
3408 "CREATE DATABASE %s WITH TEMPLATE = template0 "
3409 "OID = %u STRATEGY = FILE_COPY",
3411 }
3412 else
3413 {
3415 qdatname);
3416 }
3418 {
3421 }
3422
3430 else
3432 datlocprovider);
3433
3435 {
3438 }
3439 else
3440 {
3442 {
3445 }
3447 {
3450 }
3451 }
3452 if (locale)
3453 {
3456 else
3458
3460 }
3461
3463 {
3466 }
3467
3468 /*
3469 * For binary upgrade, carry over the collation version. For normal
3470 * dump/restore, omit the version, so that it is computed upon restore.
3471 */
3473 {
3475 {
3479 fout);
3480 }
3481 }
3482
3483 /*
3484 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3485 * thing; the decision whether to specify a tablespace should be left till
3486 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3487 * label the DATABASE entry with the tablespace and let the normal
3488 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3489 * attention to default_tablespace, so that won't work.
3490 */
3492 !dopt->outputNoTablespaces)
3496
3498 qdatname);
3499
3501
3506 .owner = dba,
3508 .section = SECTION_PRE_DATA,
3510 .dropStmt = delQry->data));
3511
3512 /* Compute correct tag for archive entry */
3514
3515 /* Dump DB comment if any */
3516 {
3517 /*
3518 * 8.2 and up keep comments on shared objects in a shared table, so we
3519 * cannot use the dumpComment() code used for other database objects.
3520 * Be careful that the ArchiveEntry parameters match that function.
3521 */
3523
3525 {
3527
3528 /*
3529 * Generates warning when loaded into a differently-named
3530 * database.
3531 */
3535
3538 .owner = dba,
3539 .description = "COMMENT",
3540 .section = SECTION_NONE,
3541 .createStmt = dbQry->data,
3542 .deps = &dbDumpId,
3543 .nDeps = 1));
3544 }
3545 }
3546
3547 /* Dump DB security label, if enabled */
3549 {
3552
3554
3562 .owner = dba,
3563 .description = "SECURITY LABEL",
3564 .section = SECTION_NONE,
3565 .createStmt = seclabelQry->data,
3566 .deps = &dbDumpId,
3567 .nDeps = 1));
3570 }
3571
3572 /*
3573 * Dump ACL if any. Note that we do not support initial privileges
3574 * (pg_init_privs) on databases.
3575 */
3576 dbdacl.privtype = 0;
3578
3582
3583 /*
3584 * Now construct a DATABASE PROPERTIES archive entry to restore any
3585 * non-default database-level properties. (The reason this must be
3586 * separate is that we cannot put any additional commands into the TOC
3587 * entry that has CREATE DATABASE. pg_restore would execute such a group
3588 * in an implicit transaction block, and the backend won't allow CREATE
3589 * DATABASE in that context.)
3590 */
3593
3597
3599 {
3601 qdatname);
3602
3603 /*
3604 * The backend won't accept DROP DATABASE on a template database. We
3605 * can deal with that by removing the template marking before the DROP
3606 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3607 * since no such command is currently supported, fake it with a direct
3608 * UPDATE on pg_database.
3609 */
3611 "SET datistemplate = false WHERE datname = ");
3614 }
3615
3616 /*
3617 * We do not restore pg_database.dathasloginevt because it is set
3618 * automatically on login event trigger creation.
3619 */
3620
3621 /* Add database-specific SET options */
3623
3624 /*
3625 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3626 * entry, too, for lack of a better place.
3627 */
3629 {
3632 "SET datfrozenxid = '%u', datminmxid = '%u'\n"
3633 "WHERE datname = ",
3634 frozenxid, minmxid);
3637 }
3638
3642 .owner = dba,
3644 .section = SECTION_PRE_DATA,
3646 .dropStmt = delQry->data,
3647 .deps = &dbDumpId));
3648
3649 /*
3650 * pg_largeobject comes from the old system intact, so set its
3651 * relfrozenxids, relminmxids and relfilenode.
3652 *
3653 * pg_largeobject_metadata also comes from the old system intact for
3654 * upgrades from v16 and newer, so set its relfrozenxids, relminmxids, and
3655 * relfilenode, too. pg_upgrade can't copy/link the files from older
3656 * versions because aclitem (needed by pg_largeobject_metadata.lomacl)
3657 * changed its storage format in v16.
3658 */
3660 {
3668 ii_relfilenode,
3669 ii_oid,
3670 ii_relminmxid;
3671
3674 "FROM pg_catalog.pg_class\n"
3675 "WHERE oid IN (%u, %u, %u, %u);\n",
3678 else
3680 "FROM pg_catalog.pg_class\n"
3681 "WHERE oid IN (%u, %u);\n",
3683
3685
3690
3691 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3692 appendPQExpBufferStr(lomHorizonQry, "\n-- For binary upgrade, set pg_largeobject_metadata relfrozenxid and relminmxid\n");
3693 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3694 appendPQExpBufferStr(lomOutQry, "\n-- For binary upgrade, preserve pg_largeobject_metadata and index relfilenodes\n");
3696 {
3697 Oid oid;
3698 RelFileNumber relfilenumber;
3701
3704
3706 oid == LargeObjectLOidPNIndexId)
3707 {
3710 }
3711 else
3712 {
3715 }
3716
3718 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
3719 "WHERE oid = %u;\n",
3723
3725 oid == LargeObjectMetadataRelationId)
3727 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
3728 relfilenumber);
3730 oid == LargeObjectMetadataOidIndexId)
3732 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
3733 relfilenumber);
3734 }
3735
3737 "TRUNCATE pg_catalog.pg_largeobject;\n");
3739 "TRUNCATE pg_catalog.pg_largeobject_metadata;\n");
3740
3743
3747 .section = SECTION_PRE_DATA,
3748 .createStmt = loOutQry->data));
3749
3754 .section = SECTION_PRE_DATA,
3755 .createStmt = lomOutQry->data));
3756
3758
3764 }
3765
3766 PQclear(res);
3767
3773}
3774
3775/*
3776 * Collect any database-specific or role-and-database-specific SET options
3777 * for this database, and append them to outbuf.
3778 */
3779static void
3782{
3785 PGresult *res;
3786
3787 /* First collect database-specific options */
3789 "WHERE setrole = 0 AND setdatabase = '%u'::oid",
3790 dboid);
3791
3793
3797 outbuf);
3798
3799 PQclear(res);
3800
3801 /* Now look for role-and-database-specific options */
3803 "FROM pg_db_role_setting s, pg_roles r "
3804 "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
3805 dboid);
3806
3808
3813 outbuf);
3814
3815 PQclear(res);
3816
3818}
3819
3820/*
3821 * dumpEncoding: put the correct encoding into the archive
3822 */
3823static void
3825{
3828
3830
3834
3838 .section = SECTION_PRE_DATA,
3839 .createStmt = qry->data));
3840
3841 destroyPQExpBuffer(qry);
3842}
3843
3844
3845/*
3846 * dumpStdStrings: put the correct escape string behavior into the archive
3847 */
3848static void
3850{
3853
3855 stdstrings);
3856
3858 stdstrings);
3859
3863 .section = SECTION_PRE_DATA,
3864 .createStmt = qry->data));
3865
3866 destroyPQExpBuffer(qry);
3867}
3868
3869/*
3870 * dumpSearchPath: record the active search_path in the archive
3871 */
3872static void
3874{
3877 PGresult *res;
3881
3882 /*
3883 * We use the result of current_schemas(), not the search_path GUC,
3884 * because that might contain wildcards such as "$user", which won't
3885 * necessarily have the same value during restore. Also, this way avoids
3886 * listing schemas that may appear in search_path but not actually exist,
3887 * which seems like a prudent exclusion.
3888 */
3889 res = ExecuteSqlQueryForSingleRow(AH,
3890 "SELECT pg_catalog.current_schemas(false)");
3891
3894
3895 /*
3896 * We use set_config(), not a simple "SET search_path" command, because
3897 * the latter has less-clean behavior if the search path is empty. While
3898 * that's likely to get fixed at some point, it seems like a good idea to
3899 * be as backwards-compatible as possible in what we put into archives.
3900 */
3902 {
3906 }
3907
3911
3913
3917 .section = SECTION_PRE_DATA,
3918 .createStmt = qry->data));
3919
3920 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3922
3924 PQclear(res);
3925 destroyPQExpBuffer(qry);
3926 destroyPQExpBuffer(path);
3927}
3928
3929
3930/*
3931 * getLOs:
3932 * Collect schema-level data about large objects
3933 */
3934static void
3936{
3939 PGresult *res;
3940 int ntups;
3942 int n;
3947
3949
3950 /*
3951 * Fetch LO OIDs and owner/ACL data. Order the data so that all the blobs
3952 * with the same owner/ACL appear together.
3953 */
3955 "SELECT oid, lomowner, lomacl, "
3956 "acldefault('L', lomowner) AS acldefault "
3957 "FROM pg_largeobject_metadata ");
3958
3959 /*
3960 * For binary upgrades, we transfer pg_largeobject_metadata via COPY or by
3961 * copying/linking its files from the old cluster. On such upgrades, we
3962 * only need to consider large objects that have comments or security
3963 * labels, since we still restore those objects via COMMENT/SECURITY LABEL
3964 * commands.
3965 */
3968 "WHERE oid IN "
3969 "(SELECT objoid FROM pg_description "
3971 "UNION SELECT objoid FROM pg_seclabel "
3973
3975 "ORDER BY lomowner, lomacl::pg_catalog.text, oid");
3976
3978
3983
3984 ntups = PQntuples(res);
3985
3986 /*
3987 * Group the blobs into suitably-sized groups that have the same owner and
3988 * ACL setting, and build a metadata and a data DumpableObject for each
3989 * group. (If we supported initprivs for blobs, we'd have to insist that
3990 * groups also share initprivs settings, since the DumpableObject only has
3991 * room for one.) i is the index of the first tuple in the current group,
3992 * and n is the number of tuples we include in the group.
3993 */
3995 {
4002
4003 /* Scan to find first tuple not to be included in group */
4004 n = 1;
4006 {
4009 break;
4010 n++;
4011 }
4012
4013 /* Build the metadata DumpableObject */
4015
4020
4021 if (n > 1)
4024 else
4029 loinfo->dacl.privtype = 0;
4032 loinfo->numlos = n;
4034 /* Collect OIDs of the remaining blobs in this group */
4035 for (int k = 1; k < n; k++)
4036 {
4038
4040
4041 /* Make sure we can look up loinfo by any of the blobs' OIDs */
4045 }
4046
4047 /* LOs have data */
4049
4050 /* Mark whether LO group has a non-empty ACL */
4053
4054 /*
4055 * In binary upgrade mode, pg_largeobject and pg_largeobject_metadata
4056 * are transferred via COPY or by copying/linking the files from the
4057 * old cluster. Thus, we do not need to dump LO data, definitions, or
4058 * ACLs.
4059 */
4062
4063 /*
4064 * Create a "BLOBS" data item for the group, too. This is just a
4065 * placeholder for sorting; it carries no data now.
4066 */
4073 /* Set up explicit dependency from data to metadata */
4077 }
4078
4079 PQclear(res);
4081}
4082
4083/*
4084 * dumpLO
4085 *
4086 * dump the definition (metadata) of the given large object group
4087 */
4088static void
4090{
4092
4093 /*
4094 * The "definition" is just a newline-separated list of OIDs. We need to
4095 * put something into the dropStmt too, but it can just be a comment.
4096 */
4099
4103 .owner = loinfo->rolname,
4104 .description = "BLOB METADATA",
4105 .section = SECTION_DATA,
4106 .createStmt = cquery->data,
4107 .dropStmt = "-- dummy"));
4108
4109 /*
4110 * Dump per-blob comments and seclabels if any. We assume these are rare
4111 * enough that it's okay to generate retail TOC entries for them.
4112 */
4114 DUMP_COMPONENT_SECLABEL))
4115 {
4117 {
4118 CatalogId catId;
4120
4121 /* Build identifying info for this blob */
4125
4129 catId, 0, loinfo->dobj.dumpId);
4130
4134 catId, 0, loinfo->dobj.dumpId);
4135 }
4136 }
4137
4138 /*
4139 * Dump the ACLs if any (remember that all blobs in the group will have
4140 * the same ACL). If there's just one blob, dump a simple ACL entry; if
4141 * there's more, make a "LARGE OBJECTS" entry that really contains only
4142 * the ACL for the first blob. _printTocEntry() will be cued by the tag
4143 * string to emit a mutated version for each blob.
4144 */
4146 {
4148
4149 /* Build identifying info for the first blob */
4151
4153 {
4155
4158
4162 }
4163 else
4164 {
4168 }
4169 }
4170
4172}
4173
4174/*
4175 * dumpLOs:
4176 * dump the data contents of the large objects in the given group
4177 */
4178static int
4180{
4184
4186
4188 {
4190 int loFd;
4191 int cnt;
4192
4193 /* Open the LO */
4195 if (loFd == -1)
4198
4200
4201 /* Now read it in chunks, sending data to archive */
4202 do
4203 {
4205 if (cnt < 0)
4208
4210 } while (cnt > 0);
4211
4213
4215 }
4216
4217 return 1;
4218}
4219
4220/*
4221 * getPolicies
4222 * get information about all RLS policies on dumpable tables.
4223 */
4224void
4226{
4228 PQExpBuffer query;
4230 PGresult *res;
4242 j,
4243 ntups;
4244
4245 /* No policies before 9.5 */
4247 return;
4248
4249 /* Skip if --no-policies was specified */
4251 return;
4252
4253 query = createPQExpBuffer();
4255
4256 /*
4257 * Identify tables of interest, and check which ones have RLS enabled.
4258 */
4261 {
4263
4264 /* Ignore row security on tables not to be dumped */
4266 continue;
4267
4268 /* It can't have RLS or policies if it's not a table */
4271 continue;
4272
4273 /* Add it to the list of table OIDs to be probed below */
4277
4278 /* Is RLS enabled? (That's separate from whether it has policies) */
4280 {
4282
4283 /*
4284 * We represent RLS being enabled on a table by creating a
4285 * PolicyInfo object with null polname.
4286 *
4287 * Note: use tableoid 0 so that this object won't be mistaken for
4288 * something that pg_depend entries apply to.
4289 */
4292 polinfo->dobj.catId.tableoid = 0;
4300 polinfo->polpermissive = 0;
4304 }
4305 }
4307
4308 /*
4309 * Now, read all RLS policies belonging to the tables of interest, and
4310 * create PolicyInfo objects for them. (Note that we must filter the
4311 * results server-side not locally, because we dare not apply pg_get_expr
4312 * to tables we don't have lock on.)
4313 */
4315
4316 printfPQExpBuffer(query,
4317 "SELECT pol.oid, pol.tableoid, pol.polrelid, pol.polname, pol.polcmd, ");
4320 else
4322 appendPQExpBuffer(query,
4323 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
4324 " 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, "
4325 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
4326 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
4327 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
4328 "JOIN pg_catalog.pg_policy pol ON (src.tbloid = pol.polrelid)",
4329 tbloids->data);
4330
4332
4333 ntups = PQntuples(res);
4334 if (ntups > 0)
4335 {
4345
4347
4349 {
4352
4354
4364
4367
4370 else
4372
4375 else
4377
4380 else
4383 }
4384 }
4385
4386 PQclear(res);
4387
4388 destroyPQExpBuffer(query);
4390}
4391
4392/*
4393 * dumpPolicy
4394 * dump the definition of the given policy
4395 */
4396static void
4398{
4401 PQExpBuffer query;
4405 const char *cmd;
4406 char *tag;
4407
4408 /* Do nothing if not dumping schema */
4410 return;
4411
4412 /*
4413 * If polname is NULL, then this record is just indicating that ROW LEVEL
4414 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
4415 * ROW LEVEL SECURITY.
4416 */
4418 {
4419 query = createPQExpBuffer();
4420
4423
4424 /*
4425 * We must emit the ROW SECURITY object's dependency on its table
4426 * explicitly, because it will not match anything in pg_depend (unlike
4427 * the case for other PolicyInfo objects).
4428 */
4432 .namespace = polinfo->dobj.namespace->dobj.name,
4433 .owner = tbinfo->rolname,
4434 .description = "ROW SECURITY",
4435 .section = SECTION_POST_DATA,
4436 .createStmt = query->data,
4437 .deps = &(tbinfo->dobj.dumpId),
4438 .nDeps = 1));
4439
4440 destroyPQExpBuffer(query);
4441 return;
4442 }
4443
4445 cmd = "";
4447 cmd = " FOR SELECT";
4449 cmd = " FOR INSERT";
4451 cmd = " FOR UPDATE";
4453 cmd = " FOR DELETE";
4454 else
4456 polinfo->polcmd);
4457
4458 query = createPQExpBuffer();
4461
4463
4465
4468
4471
4474
4477
4479
4482
4485
4487
4490 ARCHIVE_OPTS(.tag = tag,
4492 .owner = tbinfo->rolname,
4493 .description = "POLICY",
4494 .section = SECTION_POST_DATA,
4495 .createStmt = query->data,
4496 .dropStmt = delqry->data));
4497
4502
4503 free(tag);
4504 destroyPQExpBuffer(query);
4508}
4509
4510/*
4511 * getPublications
4512 * get information about publications
4513 */
4514void
4516{
4518 PQExpBuffer query;
4519 PGresult *res;
4534 ntups;
4535
4537 return;
4538
4539 query = createPQExpBuffer();
4540
4541 /* Get the publications. */
4543 "p.pubowner, p.puballtables, p.pubinsert, "
4544 "p.pubupdate, p.pubdelete, ");
4545
4548 else
4550
4553 else
4555
4558 else
4560
4563 else
4565
4567
4569
4570 ntups = PQntuples(res);
4571
4572 if (ntups == 0)
4574
4587
4589
4591 {
4616 {
4618 };
4619
4620 /* Decide whether we want to dump it */
4622
4623 /*
4624 * Get the list of tables for publications specified in the EXCEPT
4625 * TABLE clause.
4626 *
4627 * Although individual table entries in EXCEPT list could be stored in
4628 * PublicationRelInfo, dumpPublicationTable cannot be used to emit
4629 * them, because there is no ALTER PUBLICATION ... ADD command to add
4630 * individual table entries to the EXCEPT list.
4631 *
4632 * Therefore, the approach is to dump the complete EXCEPT list in a
4633 * single CREATE PUBLICATION statement. PublicationInfo is used to
4634 * collect this information, which is then emitted by
4635 * dumpPublication().
4636 */
4638 {
4641
4642 resetPQExpBuffer(query);
4643 appendPQExpBuffer(query,
4644 "SELECT prrelid\n"
4645 "FROM pg_catalog.pg_publication_rel\n"
4646 "WHERE prpubid = %u AND prexcept",
4648
4650
4652
4654 {
4657
4659
4661
4664 }
4665
4667 }
4668 }
4669
4670cleanup:
4671 PQclear(res);
4672
4673 destroyPQExpBuffer(query);
4674}
4675
4676/*
4677 * dumpPublication
4678 * dump the definition of the given publication
4679 */
4680static void
4682{
4685 PQExpBuffer query;
4687 bool first = true;
4688
4689 /* Do nothing if not dumping schema */
4691 return;
4692
4694 query = createPQExpBuffer();
4695
4697
4699 qpubname);
4700
4702 qpubname);
4703
4705 {
4707
4709
4710 /* Include EXCEPT (TABLE) clause if there are except_tables. */
4712 {
4714
4717 else
4720 }
4723
4726 }
4729
4732 {
4734 first = false;
4735 }
4736
4738 {
4739 if (!first)
4741
4743 first = false;
4744 }
4745
4747 {
4748 if (!first)
4750
4752 first = false;
4753 }
4754
4756 {
4757 if (!first)
4759
4761 first = false;
4762 }
4763
4765
4768
4771
4773
4777 .owner = pubinfo->rolname,
4778 .description = "PUBLICATION",
4779 .section = SECTION_POST_DATA,
4780 .createStmt = query->data,
4781 .dropStmt = delq->data));
4782
4787
4792
4794 destroyPQExpBuffer(query);
4796}
4797
4798/*
4799 * getPublicationNamespaces
4800 * get information about publication membership for dumpable schemas.
4801 */
4802void
4804{
4805 PQExpBuffer query;
4806 PGresult *res;
4814 j,
4815 ntups;
4816
4818 return;
4819
4820 query = createPQExpBuffer();
4821
4822 /* Collect all publication membership info. */
4823 appendPQExpBufferStr(query,
4824 "SELECT tableoid, oid, pnpubid, pnnspid "
4825 "FROM pg_catalog.pg_publication_namespace");
4827
4828 ntups = PQntuples(res);
4829
4834
4835 /* this allocation may be more than we need */
4837 j = 0;
4838
4840 {
4845
4846 /*
4847 * Ignore any entries for which we aren't interested in either the
4848 * publication or the rel.
4849 */
4852 continue;
4855 continue;
4856
4857 /* OK, make a DumpableObject for this relationship */
4867
4868 /* Decide whether we want to dump it */
4870
4871 j++;
4872 }
4873
4874 PQclear(res);
4875 destroyPQExpBuffer(query);
4876}
4877
4878/*
4879 * getPublicationTables
4880 * get information about publication membership for dumpable tables.
4881 */
4882void
4884{
4885 PQExpBuffer query;
4886 PGresult *res;
4896 j,
4897 ntups;
4898
4900 return;
4901
4902 query = createPQExpBuffer();
4903
4904 /* Collect all publication membership info. */
4906 {
4907 appendPQExpBufferStr(query,
4908 "SELECT tableoid, oid, prpubid, prrelid, "
4909 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4910 "(CASE\n"
4911 " WHEN pr.prattrs IS NOT NULL THEN\n"
4912 " (SELECT array_agg(attname)\n"
4913 " FROM\n"
4914 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4915 " pg_catalog.pg_attribute\n"
4916 " WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
4917 " ELSE NULL END) prattrs "
4918 "FROM pg_catalog.pg_publication_rel pr");
4921 }
4922 else
4923 appendPQExpBufferStr(query,
4924 "SELECT tableoid, oid, prpubid, prrelid, "
4925 "NULL AS prrelqual, NULL AS prattrs "
4926 "FROM pg_catalog.pg_publication_rel");
4928
4929 ntups = PQntuples(res);
4930
4937
4938 /* this allocation may be more than we need */
4940 j = 0;
4941
4943 {
4948
4949 /*
4950 * Ignore any entries for which we aren't interested in either the
4951 * publication or the rel.
4952 */
4955 continue;
4958 continue;
4959
4960 /* OK, make a DumpableObject for this relationship */
4972 else
4974
4976 {
4977 char **attnames;
4980
4982 &attnames, &nattnames))
4986 {
4987 if (k > 0)
4989
4991 }
4994 free(attnames);
4995 }
4996 else
4998
4999 /* Decide whether we want to dump it */
5001
5002 j++;
5003 }
5004
5005 PQclear(res);
5006 destroyPQExpBuffer(query);
5007}
5008
5009/*
5010 * dumpPublicationNamespace
5011 * dump the definition of the given publication schema mapping.
5012 */
5013static void
5015{
5019 PQExpBuffer query;
5020 char *tag;
5021
5022 /* Do nothing if not dumping schema */
5024 return;
5025
5027
5028 query = createPQExpBuffer();
5029
5032
5033 /*
5034 * There is no point in creating drop query as the drop is done by schema
5035 * drop.
5036 */
5039 ARCHIVE_OPTS(.tag = tag,
5041 .owner = pubinfo->rolname,
5042 .description = "PUBLICATION TABLES IN SCHEMA",
5043 .section = SECTION_POST_DATA,
5044 .createStmt = query->data));
5045
5046 /* These objects can't currently have comments or seclabels */
5047
5048 free(tag);
5049 destroyPQExpBuffer(query);
5050}
5051
5052/*
5053 * dumpPublicationTable
5054 * dump the definition of the given publication table mapping
5055 */
5056static void
5058{
5062 PQExpBuffer query;
5063 char *tag;
5064
5065 /* Do nothing if not dumping schema */
5067 return;
5068
5070
5071 query = createPQExpBuffer();
5072
5077
5080
5082 {
5083 /*
5084 * It's necessary to add parentheses around the expression because
5085 * pg_get_expr won't supply the parentheses for things like WHERE
5086 * TRUE.
5087 */
5089 }
5091
5092 /*
5093 * There is no point in creating a drop query as the drop is done by table
5094 * drop. (If you think to change this, see also _printTocEntry().)
5095 * Although this object doesn't really have ownership as such, set the
5096 * owner field anyway to ensure that the command is run by the correct
5097 * role at restore time.
5098 */
5101 ARCHIVE_OPTS(.tag = tag,
5103 .owner = pubinfo->rolname,
5104 .description = "PUBLICATION TABLE",
5105 .section = SECTION_POST_DATA,
5106 .createStmt = query->data));
5107
5108 /* These objects can't currently have comments or seclabels */
5109
5110 free(tag);
5111 destroyPQExpBuffer(query);
5112}
5113
5114/*
5115 * Is the currently connected user a superuser?
5116 */
5117static bool
5119{
5122
5124
5126 return true;
5127
5128 return false;
5129}
5130
5131/*
5132 * Set the given value to restrict_nonsystem_relation_kind value. Since
5133 * restrict_nonsystem_relation_kind is introduced in minor version releases,
5134 * the setting query is effective only where available.
5135 */
5136static void
5138{
5140 PGresult *res;
5141
5142 appendPQExpBuffer(query,
5143 "SELECT set_config(name, '%s', false) "
5144 "FROM pg_settings "
5145 "WHERE name = 'restrict_nonsystem_relation_kind'",
5146 value);
5148
5149 PQclear(res);
5150 destroyPQExpBuffer(query);
5151}
5152
5153/*
5154 * getSubscriptions
5155 * get information about subscriptions
5156 */
5157void
5159{
5161 PQExpBuffer query;
5162 PGresult *res;
5163 SubscriptionInfo *subinfo;
5187 ntups;
5188
5190 return;
5191
5193 {
5194 int n;
5195
5197 "SELECT count(*) FROM pg_subscription "
5198 "WHERE subdbid = (SELECT oid FROM pg_database"
5199 " WHERE datname = current_database())",
5200 PGRES_TUPLES_OK);
5202 if (n > 0)
5204 PQclear(res);
5205 return;
5206 }
5207
5208 query = createPQExpBuffer();
5209
5210 /* Get the subscriptions in current database. */
5211 appendPQExpBufferStr(query,
5212 "SELECT s.tableoid, s.oid, s.subname,\n"
5213 " s.subowner,\n"
5214 " s.subconninfo, s.subslotname, s.subsynccommit,\n"
5215 " s.subpublications,\n");
5216
5219 else
5221
5224 else
5226
5228 appendPQExpBufferStr(query,
5229 " s.subtwophasestate,\n"
5230 " s.subdisableonerr,\n");
5231 else
5232 appendPQExpBuffer(query,
5233 " '%c' AS subtwophasestate,\n"
5234 " false AS subdisableonerr,\n",
5236
5238 appendPQExpBufferStr(query,
5239 " s.subpasswordrequired,\n"
5240 " s.subrunasowner,\n"
5241 " s.suborigin,\n");
5242 else
5243 appendPQExpBuffer(query,
5244 " 't' AS subpasswordrequired,\n"
5245 " 't' AS subrunasowner,\n"
5246 " '%s' AS suborigin,\n",
5247 LOGICALREP_ORIGIN_ANY);
5248
5251 " s.subenabled,\n");
5252 else
5254 " false AS subenabled,\n");
5255
5257 appendPQExpBufferStr(query,
5258 " s.subfailover,\n");
5259 else
5260 appendPQExpBufferStr(query,
5261 " false AS subfailover,\n");
5262
5264 appendPQExpBufferStr(query,
5265 " s.subretaindeadtuples,\n");
5266 else
5267 appendPQExpBufferStr(query,
5268 " false AS subretaindeadtuples,\n");
5269
5271 appendPQExpBufferStr(query,
5272 " s.submaxretention,\n");
5273 else
5275
5277 appendPQExpBufferStr(query,
5278 " s.subwalrcvtimeout,\n");
5279 else
5280 appendPQExpBufferStr(query,
5281 " '-1' AS subwalrcvtimeout,\n");
5282
5285 else
5287
5288 appendPQExpBufferStr(query,
5289 "FROM pg_subscription s\n");
5290
5292 appendPQExpBufferStr(query,
5293 "LEFT JOIN pg_catalog.pg_foreign_server fs \n"
5294 " ON fs.oid = s.subserver \n");
5295
5297 appendPQExpBufferStr(query,
5298 "LEFT JOIN pg_catalog.pg_replication_origin_status o \n"
5299 " ON o.external_id = 'pg_' || s.oid::text \n");
5300
5301 appendPQExpBufferStr(query,
5302 "WHERE s.subdbid = (SELECT oid FROM pg_database\n"
5303 " WHERE datname = current_database())");
5304
5306
5307 ntups = PQntuples(res);
5308
5309 /*
5310 * Get subscription fields. We don't include subskiplsn in the dump as
5311 * after restoring the dump this value may no longer be relevant.
5312 */
5335
5337
5339 {
5347
5352 else
5372 else
5377 else
5389 else
5392
5393 /* Decide whether we want to dump it */
5395 }
5396 PQclear(res);
5397
5398 destroyPQExpBuffer(query);
5399}
5400
5401/*
5402 * getSubscriptionRelations
5403 * Get information about subscription membership for dumpable relations. This
5404 * will be used only in binary-upgrade mode for PG17 or later versions.
5405 */
5406void
5408{
5412 PGresult *res;
5417 int ntups;
5419
5422 return;
5423
5425 "SELECT srsubid, srrelid, srsubstate, srsublsn "
5426 "FROM pg_catalog.pg_subscription_rel "
5427 "ORDER BY srsubid",
5428 PGRES_TUPLES_OK);
5429 ntups = PQntuples(res);
5430 if (ntups == 0)
5432
5433 /* Get pg_subscription_rel attributes */
5438
5441 {
5444 TableInfo *tblinfo;
5445
5446 /*
5447 * If we switched to a new subscription, check if the subscription
5448 * exists.
5449 */
5451 {
5455
5457 }
5458
5459 tblinfo = findTableByOid(relid);
5462 relid);
5463
5464 /* OK, make a DumpableObject for this relationship */
5476 else
5478
5479 /* Decide whether we want to dump it */
5481 }
5482
5483cleanup:
5484 PQclear(res);
5485}
5486
5487/*
5488 * dumpSubscriptionTable
5489 * Dump the definition of the given subscription table mapping. This will be
5490 * used only in binary-upgrade mode for PG17 or later versions.
5491 */
5492static void
5494{
5497 PQExpBuffer query;
5498 char *tag;
5499
5500 /* Do nothing if not dumping schema */
5502 return;
5503
5505
5507
5508 query = createPQExpBuffer();
5509
5511 {
5512 /*
5513 * binary_upgrade_add_sub_rel_state will add the subscription relation
5514 * to pg_subscription_rel table. This will be used only in
5515 * binary-upgrade mode.
5516 */
5517 appendPQExpBufferStr(query,
5518 "\n-- For binary upgrade, must preserve the subscriber table.\n");
5519 appendPQExpBufferStr(query,
5520 "SELECT pg_catalog.binary_upgrade_add_sub_rel_state(");
5522 appendPQExpBuffer(query,
5523 ", %u, '%c'",
5524 subrinfo->tblinfo->dobj.catId.oid,
5525 subrinfo->srsubstate);
5526
5529 else
5531
5533 }
5534
5535 /*
5536 * There is no point in creating a drop query as the drop is done by table
5537 * drop. (If you think to change this, see also _printTocEntry().)
5538 * Although this object doesn't really have ownership as such, set the
5539 * owner field anyway to ensure that the command is run by the correct
5540 * role at restore time.
5541 */
5544 ARCHIVE_OPTS(.tag = tag,
5546 .owner = subinfo->rolname,
5547 .description = "SUBSCRIPTION TABLE",
5548 .section = SECTION_POST_DATA,
5549 .createStmt = query->data));
5550
5551 /* These objects can't currently have comments or seclabels */
5552
5553 free(tag);
5554 destroyPQExpBuffer(query);
5555}
5556
5557/*
5558 * dumpSubscription
5559 * dump the definition of the given subscription
5560 */
5561static void
5563{
5566 PQExpBuffer query;
5567 PQExpBuffer publications;
5572
5573 /* Do nothing if not dumping schema */
5575 return;
5576
5578 query = createPQExpBuffer();
5579
5581
5583 qsubname);
5584
5586 qsubname);
5588 {
5590 }
5591 else
5592 {
5595 }
5596
5597 /* Build list of quoted publications and append them to query. */
5600
5601 publications = createPQExpBuffer();
5603 {
5606
5608 }
5609
5610 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
5613 else
5615
5618
5623 else
5625
5628
5631
5634
5637
5640
5643
5646
5649
5652
5655
5657
5658 /*
5659 * In binary-upgrade mode, we allow the replication to continue after the
5660 * upgrade.
5661 */
5663 {
5665 {
5666 /*
5667 * Preserve the remote_lsn for the subscriber's replication
5668 * origin. This value is required to start the replication from
5669 * the position before the upgrade. This value will be stale if
5670 * the publisher gets upgraded before the subscriber node.
5671 * However, this shouldn't be a problem as the upgrade of the
5672 * publisher ensures that all the transactions were replicated
5673 * before upgrading it.
5674 */
5675 appendPQExpBufferStr(query,
5676 "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
5677 appendPQExpBufferStr(query,
5678 "SELECT pg_catalog.binary_upgrade_replorigin_advance(");
5681 }
5682
5684 {
5685 /*
5686 * Enable the subscription to allow the replication to continue
5687 * after the upgrade.
5688 */
5689 appendPQExpBufferStr(query,
5690 "\n-- For binary upgrade, must preserve the subscriber's running state.\n");
5692 }
5693 }
5694
5698 .owner = subinfo->rolname,
5699 .description = "SUBSCRIPTION",
5700 .section = SECTION_POST_DATA,
5701 .createStmt = query->data,
5702 .dropStmt = delq->data));
5703
5708
5713
5714 destroyPQExpBuffer(publications);
5716
5718 destroyPQExpBuffer(query);
5720}
5721
5722/*
5723 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
5724 * the object needs.
5725 */
5726static void
5728 PQExpBuffer create,
5731 const char *keyword,
5732 const char *objname)
5733{
5735 {
5737 PGresult *res;
5738 PQExpBuffer query;
5739 int ntups;
5742
5743 /* dodge fmtId() non-reentrancy */
5745
5746 query = createPQExpBuffer();
5747 appendPQExpBuffer(query,
5748 "SELECT e.extname "
5749 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5750 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5751 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5752 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5753 catalog,
5756 ntups = PQntuples(res);
5759 {
5761 keyword, nm,
5763 }
5764
5765 PQclear(res);
5766 destroyPQExpBuffer(query);
5768 }
5769}
5770
5773{
5774 /*
5775 * If the old version didn't assign an array type, but the new version
5776 * does, we must select an unused type OID to assign. This currently only
5777 * happens for domains, when upgrading pre-v11 to v11 and up.
5778 *
5779 * Note: local state here is kind of ugly, but we must have some, since we
5780 * mustn't choose the same unused OID more than once.
5781 */
5783 PGresult *res;
5785
5786 do
5787 {
5788 ++next_possible_free_oid;
5790 "SELECT EXISTS(SELECT 1 "
5791 "FROM pg_catalog.pg_type "
5792 "WHERE oid = '%u'::pg_catalog.oid);",
5793 next_possible_free_oid);
5796 PQclear(res);
5798
5800}
5801
5802static void
5808{
5810 PGresult *res;
5815
5818 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5819 pg_type_oid);
5820
5824 else
5826
5829
5831 {
5833 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5835 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5836 pg_type_array_oid);
5837 }
5838
5839 /*
5840 * Pre-set the multirange type oid and its own array type oid.
5841 */
5843 {
5845 {
5847 "SELECT t.oid, t.typarray "
5848 "FROM pg_catalog.pg_type t "
5849 "JOIN pg_catalog.pg_range r "
5850 "ON t.oid = r.rngmultitypid "
5851 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5852 pg_type_oid);
5853
5855
5858
5859 PQclear(res);
5860 }
5861 else
5862 {
5865 }
5866
5868 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5870 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5871 pg_type_multirange_oid);
5873 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5875 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5876 pg_type_multirange_array_oid);
5877 }
5878
5880}
5881
5882static void
5886{
5888
5892}
5893
5894/*
5895 * bsearch() comparator for BinaryUpgradeClassOidItem
5896 */
5897static int
5899{
5902
5904}
5905
5906/*
5907 * collectBinaryUpgradeClassOids
5908 *
5909 * Construct a table of pg_class information required for
5910 * binary_upgrade_set_pg_class_oids(). The table is sorted by OID for speed in
5911 * lookup.
5912 */
5913static void
5915{
5916 PGresult *res;
5917 const char *query;
5918
5919 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5920 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5921 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5922 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5923 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5924 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5925 "ORDER BY c.oid;";
5926
5928
5930 binaryUpgradeClassOids =
5932
5934 {
5942 }
5943
5944 PQclear(res);
5945}
5946
5947static void
5950{
5952 BinaryUpgradeClassOidItem *entry;
5953
5955
5956 /*
5957 * Preserve the OID and relfilenumber of the table, table's index, table's
5958 * toast table and toast table's index if any.
5959 *
5960 * One complexity is that the current table definition might not require
5961 * the creation of a TOAST table, but the old database might have a TOAST
5962 * table that was created earlier, before some wide columns were dropped.
5963 * By setting the TOAST oid we force creation of the TOAST heap and index
5964 * by the new backend, so we can copy the files during binary upgrade
5965 * without worrying about this case.
5966 */
5970 BinaryUpgradeClassOidItemCmp);
5971
5973 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5974
5977 {
5979 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5980 pg_class_oid);
5981
5982 /*
5983 * Not every relation has storage. Also, in a pre-v12 database,
5984 * partitioned tables have a relfilenumber, which should not be
5985 * preserved when upgrading.
5986 */
5990 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5991 entry->relfilenumber);
5992
5993 /*
5994 * In a pre-v12 database, partitioned tables might be marked as having
5995 * toast tables, but we should ignore them if so.
5996 */
5999 {
6001 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
6002 entry->toast_oid);
6004 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
6005 entry->toast_relfilenumber);
6006
6007 /* every toast table has an index */
6009 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
6010 entry->toast_index_oid);
6012 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
6013 entry->toast_index_relfilenumber);
6014 }
6015 }
6016 else
6017 {
6018 /* Preserve the OID and relfilenumber of the index */
6020 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
6021 pg_class_oid);
6023 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
6024 entry->relfilenumber);
6025 }
6026
6028}
6029
6030/*
6031 * If the DumpableObject is a member of an extension, add a suitable
6032 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
6033 *
6034 * For somewhat historical reasons, objname should already be quoted,
6035 * but not objnamespace (if any).
6036 */
6037static void
6040 const char *objtype,
6041 const char *objname,
6043{
6046
6048 return;
6049
6050 /*
6051 * Find the parent extension. We could avoid this search if we wanted to
6052 * add a link field to DumpableObject, but the space costs of that would
6053 * be considerable. We assume that member objects could only have a
6054 * direct dependency on their own extension, not any others.
6055 */
6057 {
6060 break;
6062 }
6065 objtype, objname);
6066
6068 "\n-- For binary upgrade, handle extension membership the hard way\n");
6071 objtype);
6075}
6076
6077/*
6078 * getNamespaces:
6079 * get information about all namespaces in the system catalogs
6080 */
6081void
6083{
6084 PGresult *res;
6085 int ntups;
6087 PQExpBuffer query;
6095
6096 query = createPQExpBuffer();
6097
6098 /*
6099 * we fetch all namespaces including system ones, so that every object we
6100 * read in can be linked to a containing namespace.
6101 */
6103 "n.nspowner, "
6104 "n.nspacl, "
6105 "acldefault('n', n.nspowner) AS acldefault "
6106 "FROM pg_namespace n");
6107
6109
6110 ntups = PQntuples(res);
6111
6113
6120
6122 {
6123 const char *nspowner;
6124
6137
6138 /* Decide whether to dump this namespace */
6140
6141 /* Mark whether namespace has an ACL */
6144
6145 /*
6146 * We ignore any pg_init_privs.initprivs entry for the public schema
6147 * and assume a predetermined default, for several reasons. First,
6148 * dropping and recreating the schema removes its pg_init_privs entry,
6149 * but an empty destination database starts with this ACL nonetheless.
6150 * Second, we support dump/reload of public schema ownership changes.
6151 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
6152 * initprivs continues to reflect the initial owner. Hence,
6153 * synthesize the value that nspacl will have after the restore's
6154 * ALTER SCHEMA OWNER. Third, this makes the destination database
6155 * match the source's ACL, even if the latter was an initdb-default
6156 * ACL, which changed in v15. An upgrade pulls in changes to most
6157 * system object ACLs that the DBA had not customized. We've made the
6158 * public schema depart from that, because changing its ACL so easily
6159 * breaks applications.
6160 */
6162 {
6165
6166 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
6177
6181
6184 }
6185 }
6186
6187 PQclear(res);
6188 destroyPQExpBuffer(query);
6189}
6190
6191/*
6192 * findNamespace:
6193 * given a namespace OID, look up the info read by getNamespaces
6194 */
6197{
6199
6204}
6205
6206/*
6207 * getExtensions:
6208 * read all extensions in the system catalogs and return them in the
6209 * ExtensionInfo* structure
6210 *
6211 * numExtensions is set to the number of extensions read in
6212 */
6213ExtensionInfo *
6215{
6217 PGresult *res;
6218 int ntups;
6220 PQExpBuffer query;
6230
6231 query = createPQExpBuffer();
6232
6234 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
6235 "FROM pg_extension x "
6236 "JOIN pg_namespace n ON n.oid = x.extnamespace");
6237
6239
6240 ntups = PQntuples(res);
6241 if (ntups == 0)
6243
6245
6254
6256 {
6267
6268 /* Decide whether we want to dump it */
6270 }
6271
6272cleanup:
6273 PQclear(res);
6274 destroyPQExpBuffer(query);
6275
6276 *numExtensions = ntups;
6277
6279}
6280
6281/*
6282 * getTypes:
6283 * get information about all types in the system catalogs
6284 *
6285 * NB: this must run after getFuncs() because we assume we can do
6286 * findFuncByOid().
6287 */
6288void
6290{
6291 PGresult *res;
6292 int ntups;
6311
6312 /*
6313 * we include even the built-in types because those may be used as array
6314 * elements by user-defined types
6315 *
6316 * we filter out the built-in types when we dump out the types
6317 *
6318 * same approach for undefined (shell) types and array types
6319 *
6320 * Note: as of 8.3 we can reliably detect whether a type is an
6321 * auto-generated array type by checking the element type's typarray.
6322 * (Before that the test is capable of generating false positives.) We
6323 * still check for name beginning with '_', though, so as to avoid the
6324 * cost of the subselect probe for all standard types. This would have to
6325 * be revisited if the backend ever allows renaming of array types.
6326 */
6328 "typnamespace, typacl, "
6329 "acldefault('T', typowner) AS acldefault, "
6330 "typowner, "
6331 "typelem, typrelid, typarray, "
6332 "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
6333 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
6334 "typtype, typisdefined, "
6335 "typname[0] = '_' AND typelem != 0 AND "
6336 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
6337 "FROM pg_type");
6338
6340
6341 ntups = PQntuples(res);
6342
6344
6359
6361 {
6380
6383 else
6385
6388 else
6390
6392
6395 else
6397
6398 /* Decide whether we want to dump it */
6400
6401 /* Mark whether type has an ACL */
6404
6405 /*
6406 * If it's a domain, fetch info about its constraints, if any
6407 */
6414
6415 /*
6416 * If it's a base type, make a DumpableObject representing a shell
6417 * definition of the type. We will need to dump that ahead of the I/O
6418 * functions for the type. Similarly, range types need a shell
6419 * definition in case they have a canonicalize function.
6420 *
6421 * Note: the shell type doesn't have a catId. You might think it
6422 * should copy the base type's catId, but then it might capture the
6423 * pg_depend entries for the type, which we don't want.
6424 */
6428 {
6437
6438 /*
6439 * Initially mark the shell type as not to be dumped. We'll only
6440 * dump it if the I/O or canonicalize functions need to be dumped;
6441 * this is taken care of while sorting dependencies.
6442 */
6444 }
6445 }
6446
6447 PQclear(res);
6448
6449 destroyPQExpBuffer(query);
6450}
6451
6452/*
6453 * getOperators:
6454 * get information about all operators in the system catalogs
6455 */
6456void
6458{
6459 PGresult *res;
6460 int ntups;
6473
6474 /*
6475 * find all operators, including builtin operators; we filter out
6476 * system-defined operators at dump-out time.
6477 */
6478
6480 "oprnamespace, "
6481 "oprowner, "
6482 "oprkind, "
6483 "oprleft, "
6484 "oprright, "
6485 "oprcode::oid AS oprcode "
6486 "FROM pg_operator");
6487
6489
6490 ntups = PQntuples(res);
6491
6493
6503
6505 {
6518
6519 /* Decide whether we want to dump it */
6521 }
6522
6523 PQclear(res);
6524
6525 destroyPQExpBuffer(query);
6526}
6527
6528/*
6529 * getCollations:
6530 * get information about all collations in the system catalogs
6531 */
6532void
6534{
6535 PGresult *res;
6536 int ntups;
6538 PQExpBuffer query;
6546
6547 query = createPQExpBuffer();
6548
6549 /*
6550 * find all collations, including builtin collations; we filter out
6551 * system-defined collations at dump-out time.
6552 */
6553
6555 "collnamespace, "
6556 "collowner, "
6557 "collencoding "
6558 "FROM pg_collation");
6559
6561
6562 ntups = PQntuples(res);
6563
6565
6572
6574 {
6584
6585 /* Decide whether we want to dump it */
6587 }
6588
6589 PQclear(res);
6590
6591 destroyPQExpBuffer(query);
6592}
6593
6594/*
6595 * getConversions:
6596 * get information about all conversions in the system catalogs
6597 */
6598void
6600{
6601 PGresult *res;
6602 int ntups;
6604 PQExpBuffer query;
6611
6612 query = createPQExpBuffer();
6613
6614 /*
6615 * find all conversions, including builtin conversions; we filter out
6616 * system-defined conversions at dump-out time.
6617 */
6618
6620 "connamespace, "
6621 "conowner "
6622 "FROM pg_conversion");
6623
6625
6626 ntups = PQntuples(res);
6627
6629
6635
6637 {
6646
6647 /* Decide whether we want to dump it */
6649 }
6650
6651 PQclear(res);
6652
6653 destroyPQExpBuffer(query);
6654}
6655
6656/*
6657 * getAccessMethods:
6658 * get information about all user-defined access methods
6659 */
6660void
6662{
6663 PGresult *res;
6664 int ntups;
6666 PQExpBuffer query;
6673
6674 query = createPQExpBuffer();
6675
6676 /*
6677 * Select all access methods from pg_am table. v9.6 introduced CREATE
6678 * ACCESS METHOD, so earlier versions usually have only built-in access
6679 * methods. v9.6 also changed the access method API, replacing dozens of
6680 * pg_am columns with amhandler. Even if a user created an access method
6681 * by "INSERT INTO pg_am", we have no way to translate pre-v9.6 pg_am
6682 * columns to a v9.6+ CREATE ACCESS METHOD. Hence, before v9.6, read
6683 * pg_am just to facilitate findAccessMethodByOid() providing the
6684 * OID-to-name mapping.
6685 */
6688 appendPQExpBufferStr(query,
6689 "amtype, "
6690 "amhandler::pg_catalog.regproc AS amhandler ");
6691 else
6692 appendPQExpBufferStr(query,
6693 "'i'::pg_catalog.\"char\" AS amtype, "
6694 "'-'::pg_catalog.regproc AS amhandler ");
6696
6698
6699 ntups = PQntuples(res);
6700
6702
6708
6710 {
6719
6720 /* Decide whether we want to dump it */
6722 }
6723
6724 PQclear(res);
6725
6726 destroyPQExpBuffer(query);
6727}
6728
6729
6730/*
6731 * getOpclasses:
6732 * get information about all opclasses in the system catalogs
6733 */
6734void
6736{
6737 PGresult *res;
6738 int ntups;
6748
6749 /*
6750 * find all opclasses, including builtin opclasses; we filter out
6751 * system-defined opclasses at dump-out time.
6752 */
6753
6755 "opcnamespace, "
6756 "opcowner "
6757 "FROM pg_opclass");
6758
6760
6761 ntups = PQntuples(res);
6762
6764
6771
6773 {
6783
6784 /* Decide whether we want to dump it */
6786 }
6787
6788 PQclear(res);
6789
6790 destroyPQExpBuffer(query);
6791}
6792
6793/*
6794 * getOpfamilies:
6795 * get information about all opfamilies in the system catalogs
6796 */
6797void
6799{
6800 PGresult *res;
6801 int ntups;
6803 PQExpBuffer query;
6811
6812 query = createPQExpBuffer();
6813
6814 /*
6815 * find all opfamilies, including builtin opfamilies; we filter out
6816 * system-defined opfamilies at dump-out time.
6817 */
6818
6820 "opfnamespace, "
6821 "opfowner "
6822 "FROM pg_opfamily");
6823
6825
6826 ntups = PQntuples(res);
6827
6829
6836
6838 {
6848
6849 /* Decide whether we want to dump it */
6851 }
6852
6853 PQclear(res);
6854
6855 destroyPQExpBuffer(query);
6856}
6857
6858/*
6859 * getAggregates:
6860 * get information about all user-defined aggregates in the system catalogs
6861 */
6862void
6864{
6866 PGresult *res;
6867 int ntups;
6880
6881 /*
6882 * Find all interesting aggregates. See comment in getFuncs() for the
6883 * rationale behind the filtering logic.
6884 */
6886 {
6888
6890 : "p.proisagg");
6891
6893 "p.proname AS aggname, "
6894 "p.pronamespace AS aggnamespace, "
6895 "p.pronargs, p.proargtypes, "
6896 "p.proowner, "
6897 "p.proacl AS aggacl, "
6898 "acldefault('f', p.proowner) AS acldefault "
6899 "FROM pg_proc p "
6900 "LEFT JOIN pg_init_privs pip ON "
6901 "(p.oid = pip.objoid "
6902 "AND pip.classoid = 'pg_proc'::regclass "
6903 "AND pip.objsubid = 0) "
6904 "WHERE %s AND ("
6905 "p.pronamespace != "
6906 "(SELECT oid FROM pg_namespace "
6907 "WHERE nspname = 'pg_catalog') OR "
6908 "p.proacl IS DISTINCT FROM pip.initprivs",
6909 agg_check);
6911 appendPQExpBufferStr(query,
6912 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6913 "classid = 'pg_proc'::regclass AND "
6914 "objid = p.oid AND "
6915 "refclassid = 'pg_extension'::regclass AND "
6916 "deptype = 'e')");
6918 }
6919 else
6920 {
6922 "pronamespace AS aggnamespace, "
6923 "pronargs, proargtypes, "
6924 "proowner, "
6925 "proacl AS aggacl, "
6926 "acldefault('f', proowner) AS acldefault "
6927 "FROM pg_proc p "
6928 "WHERE proisagg AND ("
6929 "pronamespace != "
6930 "(SELECT oid FROM pg_namespace "
6931 "WHERE nspname = 'pg_catalog')");
6933 appendPQExpBufferStr(query,
6934 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6935 "classid = 'pg_proc'::regclass AND "
6936 "objid = p.oid AND "
6937 "refclassid = 'pg_extension'::regclass AND "
6938 "deptype = 'e')");
6940 }
6941
6943
6944 ntups = PQntuples(res);
6945
6947
6957
6959 {
6977 else
6978 {
6983 }
6985
6986 /* Decide whether we want to dump it */
6988
6989 /* Mark whether aggregate has an ACL */
6992 }
6993
6994 PQclear(res);
6995
6996 destroyPQExpBuffer(query);
6997}
6998
6999/*
7000 * getFuncs:
7001 * get information about all user-defined functions in the system catalogs
7002 */
7003void
7005{
7007 PGresult *res;
7008 int ntups;
7011 FuncInfo *finfo;
7023
7024 /*
7025 * Find all interesting functions. This is a bit complicated:
7026 *
7027 * 1. Always exclude aggregates; those are handled elsewhere.
7028 *
7029 * 2. Always exclude functions that are internally dependent on something
7030 * else, since presumably those will be created as a result of creating
7031 * the something else. This currently acts only to suppress constructor
7032 * functions for range types. Note this is OK only because the
7033 * constructors don't have any dependencies the range type doesn't have;
7034 * otherwise we might not get creation ordering correct.
7035 *
7036 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
7037 * they're members of extensions and we are in binary-upgrade mode then
7038 * include them, since we want to dump extension members individually in
7039 * that mode. Also, if they are used by casts or transforms then we need
7040 * to gather the information about them, though they won't be dumped if
7041 * they are built-in. Also, in 9.6 and up, include functions in
7042 * pg_catalog if they have an ACL different from what's shown in
7043 * pg_init_privs (so we have to join to pg_init_privs; annoying).
7044 */
7046 {
7048
7050 : "NOT p.proisagg");
7051
7052 appendPQExpBuffer(query,
7053 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
7054 "p.pronargs, p.proargtypes, p.prorettype, "
7055 "p.proacl, "
7056 "acldefault('f', p.proowner) AS acldefault, "
7057 "p.pronamespace, "
7058 "p.proowner "
7059 "FROM pg_proc p "
7060 "LEFT JOIN pg_init_privs pip ON "
7061 "(p.oid = pip.objoid "
7062 "AND pip.classoid = 'pg_proc'::regclass "
7063 "AND pip.objsubid = 0) "
7064 "WHERE %s"
7065 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
7066 "WHERE classid = 'pg_proc'::regclass AND "
7067 "objid = p.oid AND deptype = 'i')"
7068 "\n AND ("
7069 "\n pronamespace != "
7070 "(SELECT oid FROM pg_namespace "
7071 "WHERE nspname = 'pg_catalog')"
7072 "\n OR EXISTS (SELECT 1 FROM pg_cast"
7073 "\n WHERE pg_cast.oid > %u "
7074 "\n AND p.oid = pg_cast.castfunc)"
7075 "\n OR EXISTS (SELECT 1 FROM pg_transform"
7076 "\n WHERE pg_transform.oid > %u AND "
7077 "\n (p.oid = pg_transform.trffromsql"
7078 "\n OR p.oid = pg_transform.trftosql))",
7079 not_agg_check,
7080 g_last_builtin_oid,
7081 g_last_builtin_oid);
7083 appendPQExpBufferStr(query,
7084 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7085 "classid = 'pg_proc'::regclass AND "
7086 "objid = p.oid AND "
7087 "refclassid = 'pg_extension'::regclass AND "
7088 "deptype = 'e')");
7089 appendPQExpBufferStr(query,
7090 "\n OR p.proacl IS DISTINCT FROM pip.initprivs");
7092 }
7093 else
7094 {
7095 appendPQExpBuffer(query,
7096 "SELECT tableoid, oid, proname, prolang, "
7097 "pronargs, proargtypes, prorettype, proacl, "
7098 "acldefault('f', proowner) AS acldefault, "
7099 "pronamespace, "
7100 "proowner "
7101 "FROM pg_proc p "
7102 "WHERE NOT proisagg"
7103 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
7104 "WHERE classid = 'pg_proc'::regclass AND "
7105 "objid = p.oid AND deptype = 'i')"
7106 "\n AND ("
7107 "\n pronamespace != "
7108 "(SELECT oid FROM pg_namespace "
7109 "WHERE nspname = 'pg_catalog')"
7110 "\n OR EXISTS (SELECT 1 FROM pg_cast"
7111 "\n WHERE pg_cast.oid > '%u'::oid"
7112 "\n AND p.oid = pg_cast.castfunc)",
7113 g_last_builtin_oid);
7114
7116 appendPQExpBuffer(query,
7117 "\n OR EXISTS (SELECT 1 FROM pg_transform"
7118 "\n WHERE pg_transform.oid > '%u'::oid"
7119 "\n AND (p.oid = pg_transform.trffromsql"
7120 "\n OR p.oid = pg_transform.trftosql))",
7121 g_last_builtin_oid);
7122
7124 appendPQExpBufferStr(query,
7125 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
7126 "classid = 'pg_proc'::regclass AND "
7127 "objid = p.oid AND "
7128 "refclassid = 'pg_extension'::regclass AND "
7129 "deptype = 'e')");
7131 }
7132
7134
7135 ntups = PQntuples(res);
7136
7138
7150
7152 {
7170 else
7171 {
7175 }
7177
7178 /* Decide whether we want to dump it */
7180
7181 /* Mark whether function has an ACL */
7184 }
7185
7186 PQclear(res);
7187
7188 destroyPQExpBuffer(query);
7189}
7190
7191/*
7192 * getRelationStatistics
7193 * register the statistics object as a dependent of the relation.
7194 *
7195 * reltuples is passed as a string to avoid complexities in converting from/to
7196 * floating point.
7197 */
7202 char **indAttNames, int nindAttNames)
7203{
7206
7208 (relkind == RELKIND_PARTITIONED_TABLE) ||
7209 (relkind == RELKIND_INDEX) ||
7210 (relkind == RELKIND_PARTITIONED_INDEX) ||
7211 (relkind == RELKIND_MATVIEW ||
7212 relkind == RELKIND_FOREIGN_TABLE))
7213 {
7216
7220 AssignDumpId(dobj);
7223 dobj->nDeps = 1;
7224 dobj->allocDeps = 1;
7227 dobj->namespace = rel->namespace;
7229 info->relpages = relpages;
7231 info->relallvisible = relallvisible;
7232 info->relallfrozen = relallfrozen;
7233 info->relkind = relkind;
7234 info->indAttNames = indAttNames;
7235 info->nindAttNames = nindAttNames;
7236
7237 /*
7238 * Ordinarily, stats go in SECTION_DATA for tables and
7239 * SECTION_POST_DATA for indexes.
7240 *
7241 * However, the section may be updated later for materialized view
7242 * stats. REFRESH MATERIALIZED VIEW replaces the storage and resets
7243 * the stats, so the stats must be restored after the data. Also, the
7244 * materialized view definition may be postponed to SECTION_POST_DATA
7245 * (see repairMatViewBoundaryMultiLoop()).
7246 */
7248 {
7254 break;
7258 break;
7259 default:
7261 info->relkind);
7262 }
7263
7264 return info;
7265 }
7267}
7268
7269/*
7270 * getTables
7271 * read all the tables (no indexes) in the system catalogs,
7272 * and return them as an array of TableInfo structures
7273 *
7274 * *numTables is set to the number of tables read in
7275 */
7276TableInfo *
7278{
7280 PGresult *res;
7281 int ntups;
7284 TableInfo *tblinfo;
7325
7326 /*
7327 * Find all the tables and table-like objects.
7328 *
7329 * We must fetch all tables in this phase because otherwise we cannot
7330 * correctly identify inherited columns, owned sequences, etc.
7331 *
7332 * We include system catalogs, so that we can work if a user table is
7333 * defined to inherit from a system catalog (pretty weird, but...)
7334 *
7335 * Note: in this phase we should collect only a minimal amount of
7336 * information about each table, basically just enough to decide if it is
7337 * interesting. In particular, since we do not yet have lock on any user
7338 * table, we MUST NOT invoke any server-side data collection functions
7339 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
7340 * wrong answers if any concurrent DDL is happening.
7341 */
7342
7343 appendPQExpBufferStr(query,
7344 "SELECT c.tableoid, c.oid, c.relname, "
7345 "c.relnamespace, c.relkind, c.reltype, "
7346 "c.relowner, "
7347 "c.relchecks, "
7348 "c.relhasindex, c.relhasrules, c.relpages, "
7349 "c.reltuples, c.relallvisible, ");
7350
7353 else
7355
7356 appendPQExpBufferStr(query,
7357 "c.relhastriggers, c.relpersistence, "
7358 "c.reloftype, "
7359 "c.relacl, "
7361 " THEN 's'::\"char\" ELSE 'r'::\"char\" END, c.relowner) AS acldefault, "
7363 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
7364 "ELSE 0 END AS foreignserver, "
7365 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
7366 "tc.oid AS toid, "
7367 "tc.relpages AS toastpages, "
7368 "tc.reloptions AS toast_reloptions, "
7369 "d.refobjid AS owning_tab, "
7370 "d.refobjsubid AS owning_col, "
7371 "tsp.spcname AS reltablespace, ");
7372
7374 appendPQExpBufferStr(query,
7375 "false AS relhasoids, ");
7376 else
7377 appendPQExpBufferStr(query,
7378 "c.relhasoids, ");
7379
7381 appendPQExpBufferStr(query,
7382 "c.relispopulated, ");
7383 else
7384 appendPQExpBufferStr(query,
7385 "'t' as relispopulated, ");
7386
7388 appendPQExpBufferStr(query,
7389 "c.relreplident, ");
7390 else
7391 appendPQExpBufferStr(query,
7392 "'d' AS relreplident, ");
7393
7395 appendPQExpBufferStr(query,
7396 "c.relrowsecurity, c.relforcerowsecurity, ");
7397 else
7398 appendPQExpBufferStr(query,
7399 "false AS relrowsecurity, "
7400 "false AS relforcerowsecurity, ");
7401
7403 appendPQExpBufferStr(query,
7404 "c.relminmxid, tc.relminmxid AS tminmxid, ");
7405 else
7406 appendPQExpBufferStr(query,
7407 "0 AS relminmxid, 0 AS tminmxid, ");
7408
7410 appendPQExpBufferStr(query,
7411 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
7412 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
7413 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
7414 else
7415 appendPQExpBufferStr(query,
7416 "c.reloptions, NULL AS checkoption, ");
7417
7419 appendPQExpBufferStr(query,
7420 "am.amname, ");
7421 else
7422 appendPQExpBufferStr(query,
7423 "NULL AS amname, ");
7424
7426 appendPQExpBufferStr(query,
7427 "(d.deptype = 'i') IS TRUE AS is_identity_sequence, ");
7428 else
7429 appendPQExpBufferStr(query,
7430 "false AS is_identity_sequence, ");
7431
7433 appendPQExpBufferStr(query,
7434 "c.relispartition AS ispartition ");
7435 else
7436 appendPQExpBufferStr(query,
7437 "false AS ispartition ");
7438
7439 /*
7440 * Left join to pg_depend to pick up dependency info linking sequences to
7441 * their owning column, if any (note this dependency is AUTO except for
7442 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
7443 * collect the spcname.
7444 */
7445 appendPQExpBufferStr(query,
7446 "\nFROM pg_class c\n"
7447 "LEFT JOIN pg_depend d ON "
7449 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
7450 "d.objsubid = 0 AND "
7451 "d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i'))\n"
7452 "LEFT JOIN pg_tablespace tsp ON (tsp.oid = c.reltablespace)\n");
7453
7454 /*
7455 * In 9.6 and up, left join to pg_am to pick up the amname.
7456 */
7458 appendPQExpBufferStr(query,
7459 "LEFT JOIN pg_am am ON (c.relam = am.oid)\n");
7460
7461 /*
7462 * We purposefully ignore toast OIDs for partitioned tables; the reason is
7463 * that versions 10 and 11 have them, but later versions do not, so
7464 * emitting them causes the upgrade to fail.
7465 */
7466 appendPQExpBufferStr(query,
7467 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
7470
7471 /*
7472 * Restrict to interesting relkinds (in particular, not indexes). Not all
7473 * relkinds are possible in older servers, but it's not worth the trouble
7474 * to emit a version-dependent list.
7475 *
7476 * Composite-type table entries won't be dumped as such, but we have to
7477 * make a DumpableObject for them so that we can track dependencies of the
7478 * composite type (pg_depend entries for columns of the composite type
7479 * link to the pg_class entry not the pg_type entry).
7480 */
7481 appendPQExpBufferStr(query,
7482 "WHERE c.relkind IN ("
7491 "ORDER BY c.oid");
7492
7494
7495 ntups = PQntuples(res);
7496
7497 *numTables = ntups;
7498
7499 /*
7500 * Extract data from result and lock dumpable tables. We do the locking
7501 * before anything else, to minimize the window wherein a table could
7502 * disappear under us.
7503 *
7504 * Note that we have to save info about all tables here, even when dumping
7505 * only one, because we don't yet know which tables might be inheritance
7506 * ancestors of the target table.
7507 */
7509
7550
7552 {
7553 /*
7554 * Arrange to fail instead of waiting forever for a table lock.
7555 *
7556 * NB: this coding assumes that the only queries issued within the
7557 * following loop are LOCK TABLEs; else the timeout may be undesirably
7558 * applied to other things too.
7559 */
7560 resetPQExpBuffer(query);
7564 }
7565
7566 resetPQExpBuffer(query);
7567
7569 {
7572
7593 else
7596 {
7599 }
7600 else
7601 {
7604 }
7621 else
7628 else
7630 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
7632
7633 /* other fields were zeroed above */
7634
7635 /*
7636 * Decide whether we want to dump this table.
7637 */
7640 else
7642
7643 /*
7644 * Now, consider the table "interesting" if we need to dump its
7645 * definition, data or its statistics. Later on, we'll skip a lot of
7646 * data collection for uninteresting tables.
7647 *
7648 * Note: the "interesting" flag will also be set by flagInhTables for
7649 * parents of interesting tables, so that we collect necessary
7650 * inheritance info even when the parents are not themselves being
7651 * dumped. This is the main reason why we need an "interesting" flag
7652 * that's separate from the components-to-dump bitmask.
7653 */
7655 (DUMP_COMPONENT_DEFINITION |
7656 DUMP_COMPONENT_DATA |
7657 DUMP_COMPONENT_STATISTICS)) != 0;
7658
7661
7662 /* Tables have data */
7664
7665 /* Mark whether table has an ACL */
7669
7670 /* Add statistics */
7672 {
7673 RelStatsInfo *stats;
7674
7676 tblinfo[i].relpages,
7678 relallvisible, relallfrozen,
7682 }
7683
7684 /*
7685 * Read-lock target tables to make sure they aren't DROPPED or altered
7686 * in schema before we get around to dumping them.
7687 *
7688 * Note that we don't explicitly lock parents of the target tables; we
7689 * assume our lock on the child is enough to prevent schema
7690 * alterations to parent tables.
7691 *
7692 * NOTE: it'd be kinda nice to lock other relations too, not only
7693 * plain or partitioned tables, but the backend doesn't presently
7694 * allow that.
7695 *
7696 * We only need to lock the table for certain components; see
7697 * pg_dump.h
7698 */
7702 {
7703 /*
7704 * Tables are locked in batches. When dumping from a remote
7705 * server this can save a significant amount of time by reducing
7706 * the number of round trips.
7707 */
7711 else
7712 {
7715
7716 /* Arbitrarily end a batch when query length reaches 100K. */
7718 {
7719 /* Lock another batch of tables. */
7722 resetPQExpBuffer(query);
7723 }
7724 }
7725 }
7726 }
7727
7729 {
7730 /* Lock the tables in the last batch. */
7733 }
7734
7736 {
7738 }
7739
7740 PQclear(res);
7741
7742 destroyPQExpBuffer(query);
7743
7744 return tblinfo;
7745}
7746
7747/*
7748 * getOwnedSeqs
7749 * identify owned sequences and mark them as dumpable if owning table is
7750 *
7751 * We used to do this in getTables(), but it's better to do it after the
7752 * index used by findTableByOid() has been set up.
7753 */
7754void
7756{
7758
7759 /*
7760 * Force sequences that are "owned" by table columns to be dumped whenever
7761 * their owning table is being dumped.
7762 */
7764 {
7766 TableInfo *owning_tab;
7767
7769 continue; /* not an owned sequence */
7770
7775
7776 /*
7777 * For an identity sequence, dump exactly the same components for the
7778 * sequence as for the owning table. This is important because we
7779 * treat the identity sequence as an integral part of the table. For
7780 * example, there is not any DDL command that allows creation of such
7781 * a sequence independently of the table.
7782 *
7783 * For other owned sequences such as serial sequences, we need to dump
7784 * the components that are being dumped for the table and any
7785 * components that the sequence is explicitly marked with.
7786 *
7787 * We can't simply use the set of components which are being dumped
7788 * for the table as the table might be in an extension (and only the
7789 * non-extension components, eg: ACLs if changed, security labels, and
7790 * policies, are being dumped) while the sequence is not (and
7791 * therefore the definition and other components should also be
7792 * dumped).
7793 *
7794 * If the sequence is part of the extension then it should be properly
7795 * marked by checkExtensionMembership() and this will be a no-op as
7796 * the table will be equivalently marked.
7797 */
7800 else
7802
7803 /* Make sure that necessary data is available if we're dumping it */
7805 {
7808 }
7809 }
7810}
7811
7812/*
7813 * getInherits
7814 * read all the inheritance information
7815 * from the system catalogs return them in the InhInfo* structure
7816 *
7817 * numInherits is set to the number of pairs read in
7818 */
7819InhInfo *
7821{
7822 PGresult *res;
7823 int ntups;
7827
7830
7831 /* find all the inheritance information */
7833
7835
7836 ntups = PQntuples(res);
7837
7838 *numInherits = ntups;
7839
7841
7844
7846 {
7849 }
7850
7851 PQclear(res);
7852
7853 destroyPQExpBuffer(query);
7854
7856}
7857
7858/*
7859 * getPartitioningInfo
7860 * get information about partitioning
7861 *
7862 * For the most part, we only collect partitioning info about tables we
7863 * intend to dump. However, this function has to consider all partitioned
7864 * tables in the database, because we need to know about parents of partitions
7865 * we are going to dump even if the parents themselves won't be dumped.
7866 *
7867 * Specifically, what we need to know is whether each partitioned table
7868 * has an "unsafe" partitioning scheme that requires us to force
7869 * load-via-partition-root mode for its children. Currently the only case
7870 * for which we force that is hash partitioning on enum columns, since the
7871 * hash codes depend on enum value OIDs which won't be replicated across
7872 * dump-and-reload. There are other cases in which load-via-partition-root
7873 * might be necessary, but we expect users to cope with them.
7874 */
7875void
7877{
7878 PQExpBuffer query;
7879 PGresult *res;
7880 int ntups;
7881
7882 /* hash partitioning didn't exist before v11 */
7884 return;
7885 /* needn't bother if not dumping data */
7887 return;
7888
7889 query = createPQExpBuffer();
7890
7891 /*
7892 * Unsafe partitioning schemes are exactly those for which hash enum_ops
7893 * appears among the partition opclasses. We needn't check partstrat.
7894 *
7895 * Note that this query may well retrieve info about tables we aren't
7896 * going to dump and hence have no lock on. That's okay since we need not
7897 * invoke any unsafe server-side functions.
7898 */
7899 appendPQExpBufferStr(query,
7900 "SELECT partrelid FROM pg_partitioned_table WHERE\n"
7901 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7902 "ON c.opcmethod = a.oid\n"
7903 "WHERE opcname = 'enum_ops' "
7904 "AND opcnamespace = 'pg_catalog'::regnamespace "
7905 "AND amname = 'hash') = ANY(partclass)");
7906
7908
7909 ntups = PQntuples(res);
7910
7912 {
7915
7919 tabrelid);
7921 }
7922
7923 PQclear(res);
7924
7925 destroyPQExpBuffer(query);
7926}
7927
7928/*
7929 * getIndexes
7930 * get information about every index on a dumpable table
7931 *
7932 * Note: index data is not returned directly to the caller, but it
7933 * does get entered into the DumpableObject tables.
7934 */
7935void
7937{
7940 PGresult *res;
7941 int ntups;
7945 i_oid,
7946 i_indrelid,
7947 i_indexname,
7948 i_relpages,
7949 i_reltuples,
7950 i_relallvisible,
7951 i_relallfrozen,
7952 i_parentidx,
7953 i_indexdef,
7954 i_indnkeyatts,
7955 i_indnatts,
7956 i_indkey,
7957 i_indisclustered,
7958 i_indisreplident,
7959 i_indnullsnotdistinct,
7960 i_contype,
7961 i_conname,
7962 i_condeferrable,
7963 i_condeferred,
7964 i_conperiod,
7965 i_contableoid,
7966 i_conoid,
7967 i_condef,
7968 i_indattnames,
7969 i_tablespace,
7970 i_indreloptions,
7971 i_indstatcols,
7972 i_indstatvals;
7973
7974 /*
7975 * We want to perform just one query against pg_index. However, we
7976 * mustn't try to select every row of the catalog and then sort it out on
7977 * the client side, because some of the server-side functions we need
7978 * would be unsafe to apply to tables we don't have lock on. Hence, we
7979 * build an array of the OIDs of tables we care about (and now have lock
7980 * on!), and use a WHERE clause to constrain which rows are selected.
7981 */
7984 {
7986
7988 continue;
7989
7990 /*
7991 * We can ignore indexes of uninteresting tables.
7992 */
7994 continue;
7995
7996 /* OK, we need info for this table */
8000 }
8002
8003 appendPQExpBufferStr(query,
8004 "SELECT t.tableoid, t.oid, i.indrelid, "
8005 "t.relname AS indexname, "
8006 "t.relpages, t.reltuples, t.relallvisible, ");
8007
8010 else
8012
8013 appendPQExpBufferStr(query,
8014 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
8015 "i.indkey, i.indisclustered, "
8016 "c.contype, c.conname, "
8017 "c.condeferrable, c.condeferred, "
8018 "c.tableoid AS contableoid, "
8019 "c.oid AS conoid, "
8020 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
8021 "CASE WHEN i.indexprs IS NOT NULL THEN "
8022 "(SELECT pg_catalog.array_agg(attname ORDER BY attnum)"
8023 " FROM pg_catalog.pg_attribute "
8024 " WHERE attrelid = i.indexrelid) "
8025 "ELSE NULL END AS indattnames, "
8026 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
8027 "t.reloptions AS indreloptions, ");
8028
8029
8031 appendPQExpBufferStr(query,
8032 "i.indisreplident, ");
8033 else
8034 appendPQExpBufferStr(query,
8035 "false AS indisreplident, ");
8036
8038 appendPQExpBufferStr(query,
8039 "inh.inhparent AS parentidx, "
8040 "i.indnkeyatts AS indnkeyatts, "
8041 "i.indnatts AS indnatts, "
8042 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
8043 " FROM pg_catalog.pg_attribute "
8044 " WHERE attrelid = i.indexrelid AND "
8045 " attstattarget >= 0) AS indstatcols, "
8046 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
8047 " FROM pg_catalog.pg_attribute "
8048 " WHERE attrelid = i.indexrelid AND "
8049 " attstattarget >= 0) AS indstatvals, ");
8050 else
8051 appendPQExpBufferStr(query,
8052 "0 AS parentidx, "
8053 "i.indnatts AS indnkeyatts, "
8054 "i.indnatts AS indnatts, "
8055 "'' AS indstatcols, "
8056 "'' AS indstatvals, ");
8057
8059 appendPQExpBufferStr(query,
8060 "i.indnullsnotdistinct, ");
8061 else
8062 appendPQExpBufferStr(query,
8063 "false AS indnullsnotdistinct, ");
8064
8066 appendPQExpBufferStr(query,
8067 "c.conperiod ");
8068 else
8069 appendPQExpBufferStr(query,
8070 "NULL AS conperiod ");
8071
8072 /*
8073 * The point of the messy-looking outer join is to find a constraint that
8074 * is related by an internal dependency link to the index. If we find one,
8075 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
8076 * index won't have more than one internal dependency.
8077 *
8078 * Note: the check on conrelid is redundant, but useful because that
8079 * column is indexed while conindid is not.
8080 */
8082 {
8083 appendPQExpBuffer(query,
8084 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8085 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8086 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8087 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
8088 "LEFT JOIN pg_catalog.pg_constraint c "
8089 "ON (i.indrelid = c.conrelid AND "
8090 "i.indexrelid = c.conindid AND "
8091 "c.contype IN ('p','u','x')) "
8092 "LEFT JOIN pg_catalog.pg_inherits inh "
8093 "ON (inh.inhrelid = indexrelid) "
8094 "WHERE (i.indisvalid OR t2.relkind = 'p') "
8095 "AND i.indisready "
8096 "ORDER BY i.indrelid, indexname",
8097 tbloids->data);
8098 }
8099 else
8100 {
8101 /*
8102 * the test on indisready is necessary in 9.2, and harmless in
8103 * earlier/later versions
8104 */
8105 appendPQExpBuffer(query,
8106 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8107 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
8108 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
8109 "LEFT JOIN pg_catalog.pg_constraint c "
8110 "ON (i.indrelid = c.conrelid AND "
8111 "i.indexrelid = c.conindid AND "
8112 "c.contype IN ('p','u','x')) "
8113 "WHERE i.indisvalid AND i.indisready "
8114 "ORDER BY i.indrelid, indexname",
8115 tbloids->data);
8116 }
8117
8119
8120 ntups = PQntuples(res);
8121
8151
8153
8154 /*
8155 * Outer loop iterates once per table, not once per row. Incrementing of
8156 * j is handled by the inner loop.
8157 */
8158 curtblindx = -1;
8160 {
8164 int nindAttNames = 0;
8166
8167 /* Count rows for this table */
8170 break;
8171
8172 /*
8173 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8174 * order.
8175 */
8177 {
8180 break;
8181 }
8184 /* cross-check that we only got requested tables */
8186 !tbinfo->interesting)
8188 tbinfo->dobj.name);
8189
8190 /* Save data for this table */
8193
8195 {
8196 char contype;
8202
8226 {
8228 };
8229
8232 else
8234
8236 {
8238 &indAttNames, &nindAttNames))
8240 }
8241
8244 relallvisible, relallfrozen, indexkind,
8245 indAttNames, nindAttNames);
8246
8248 if (contype == 'p' || contype == 'u' || contype == 'x')
8249 {
8250 /*
8251 * If we found a constraint matching the index, create an
8252 * entry for it.
8253 */
8255
8266 constrinfo->contype = contype;
8267 if (contype == 'x')
8269 else
8278
8282 }
8283 else
8284 {
8285 /* Plain secondary index */
8287 }
8288 }
8289 }
8290
8291 PQclear(res);
8292
8293 destroyPQExpBuffer(query);
8295}
8296
8297/*
8298 * getExtendedStatistics
8299 * get information about extended-statistics objects.
8300 *
8301 * Note: extended statistics data is not returned directly to the caller, but
8302 * it does get entered into the DumpableObject tables.
8303 */
8304void
8306{
8307 PQExpBuffer query;
8308 PGresult *res;
8310 int ntups;
8319
8320 /* Extended statistics were new in v10 */
8322 return;
8323
8324 query = createPQExpBuffer();
8325
8328 "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
8329 "FROM pg_catalog.pg_statistic_ext");
8330 else
8332 "stxnamespace, stxowner, stxrelid, stxstattarget "
8333 "FROM pg_catalog.pg_statistic_ext");
8334
8336
8337 ntups = PQntuples(res);
8338
8346
8348
8350 {
8363 else
8365
8366 /* Decide whether we want to dump it */
8368
8371 }
8372
8373 PQclear(res);
8374 destroyPQExpBuffer(query);
8375}
8376
8377/*
8378 * getConstraints
8379 *
8380 * Get info about constraints on dumpable tables.
8381 *
8382 * Currently handles foreign keys only.
8383 * Unique and primary key constraints are handled with indexes,
8384 * while check constraints are processed in getTableAttrs().
8385 */
8386void
8388{
8391 PGresult *res;
8392 int ntups;
8397 i_conoid,
8398 i_conrelid,
8399 i_conname,
8400 i_confrelid,
8401 i_conindid,
8402 i_condef;
8403
8404 /*
8405 * We want to perform just one query against pg_constraint. However, we
8406 * mustn't try to select every row of the catalog and then sort it out on
8407 * the client side, because some of the server-side functions we need
8408 * would be unsafe to apply to tables we don't have lock on. Hence, we
8409 * build an array of the OIDs of tables we care about (and now have lock
8410 * on!), and use a WHERE clause to constrain which rows are selected.
8411 */
8414 {
8416
8418 continue;
8419
8420 /* OK, we need info for this table */
8424 }
8426
8427 appendPQExpBufferStr(query,
8428 "SELECT c.tableoid, c.oid, "
8429 "conrelid, conname, confrelid, ");
8432 else
8434 appendPQExpBuffer(query,
8435 "pg_catalog.pg_get_constraintdef(c.oid) AS condef\n"
8436 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8437 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
8438 "WHERE contype = 'f' ",
8439 tbloids->data);
8441 appendPQExpBufferStr(query,
8442 "AND conparentid = 0 ");
8443 appendPQExpBufferStr(query,
8444 "ORDER BY conrelid, conname");
8445
8447
8448 ntups = PQntuples(res);
8449
8457
8459
8460 curtblindx = -1;
8462 {
8465
8466 /*
8467 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8468 * order.
8469 */
8471 {
8473 {
8476 break;
8477 }
8480 }
8481
8498
8499 /*
8500 * Restoring an FK that points to a partitioned table requires that
8501 * all partition indexes have been attached beforehand. Ensure that
8502 * happens by making the constraint depend on each index partition
8503 * attach object.
8504 */
8507 {
8509
8511 {
8513 {
8515
8516 /* not our index? */
8518 continue;
8519
8522 break;
8523 }
8524 }
8525 }
8526 }
8527
8528 PQclear(res);
8529
8530 destroyPQExpBuffer(query);
8532}
8533
8534/*
8535 * addConstrChildIdxDeps
8536 *
8537 * Recursive subroutine for getConstraints
8538 *
8539 * Given an object representing a foreign key constraint and an index on the
8540 * partitioned table it references, mark the constraint object as dependent
8541 * on the DO_INDEX_ATTACH object of each index partition, recursively
8542 * drilling down to their partitions if any. This ensures that the FK is not
8543 * restored until the index is fully marked valid.
8544 */
8545static void
8547{
8548 SimplePtrListCell *cell;
8549
8551
8553 {
8555
8557
8560 }
8561}
8562
8563/*
8564 * getDomainConstraints
8565 *
8566 * Get info about constraints on a domain.
8567 */
8568static void
8570{
8573 PGresult *res;
8575 i_oid,
8576 i_conname,
8577 i_consrc,
8578 i_convalidated,
8579 i_contype;
8580 int ntups;
8581
8583 {
8584 /*
8585 * Set up query for constraint-specific details. For servers 17 and
8586 * up, domains have constraints of type 'n' as well as 'c', otherwise
8587 * just the latter.
8588 */
8589 appendPQExpBuffer(query,
8590 "PREPARE getDomainConstraints(pg_catalog.oid) AS\n"
8591 "SELECT tableoid, oid, conname, "
8592 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8593 "convalidated, contype "
8594 "FROM pg_catalog.pg_constraint "
8595 "WHERE contypid = $1 AND contype IN (%s) "
8596 "ORDER BY conname",
8598
8600
8602 }
8603
8604 printfPQExpBuffer(query,
8605 "EXECUTE getDomainConstraints('%u')",
8606 tyinfo->dobj.catId.oid);
8607
8609
8610 ntups = PQntuples(res);
8611
8618
8621
8622 /* 'i' tracks result rows; 'j' counts CHECK constraints */
8624 {
8627 ConstraintInfo *constraint;
8628
8630 {
8632 tyinfo->nDomChecks++;
8633 }
8634 else
8635 {
8638 /* use last item in array for the not-null constraint */
8640 constraint = tyinfo->notnull;
8641 }
8642
8651 constraint->contype = contype;
8654 constraint->conindex = 0;
8658
8660
8661 /*
8662 * Make the domain depend on the constraint, ensuring it won't be
8663 * output till any constraint dependencies are OK. If the constraint
8664 * has not been validated, it's going to be dumped after the domain
8665 * anyway, so this doesn't matter.
8666 */
8669 }
8670
8671 PQclear(res);
8672
8673 destroyPQExpBuffer(query);
8674}
8675
8676/*
8677 * getRules
8678 * get basic information about every rule in the system
8679 */
8680void
8682{
8683 PGresult *res;
8684 int ntups;
8695
8697 "tableoid, oid, rulename, "
8698 "ev_class AS ruletable, ev_type, is_instead, "
8699 "ev_enabled "
8700 "FROM pg_rewrite "
8701 "ORDER BY oid");
8702
8704
8705 ntups = PQntuples(res);
8706
8708
8716
8718 {
8720
8729 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
8737 {
8738 /*
8739 * If the table is a view or materialized view, force its ON
8740 * SELECT rule to be sorted before the view itself --- this
8741 * ensures that any dependencies for the rule affect the table's
8742 * positioning. Other rules are forced to appear after their
8743 * table.
8744 */
8748 {
8751 /* We'll merge the rule into CREATE VIEW, if possible */
8753 }
8754 else
8755 {
8759 }
8760 }
8761 else
8763 }
8764
8765 PQclear(res);
8766
8767 destroyPQExpBuffer(query);
8768}
8769
8770/*
8771 * getTriggers
8772 * get information about every trigger on a dumpable table
8773 *
8774 * Note: trigger data is not returned directly to the caller, but it
8775 * does get entered into the DumpableObject tables.
8776 */
8777void
8779{
8782 PGresult *res;
8783 int ntups;
8787 i_oid,
8788 i_tgrelid,
8789 i_tgname,
8790 i_tgenabled,
8791 i_tgispartition,
8792 i_tgdef;
8793
8794 /*
8795 * We want to perform just one query against pg_trigger. However, we
8796 * mustn't try to select every row of the catalog and then sort it out on
8797 * the client side, because some of the server-side functions we need
8798 * would be unsafe to apply to tables we don't have lock on. Hence, we
8799 * build an array of the OIDs of tables we care about (and now have lock
8800 * on!), and use a WHERE clause to constrain which rows are selected.
8801 */
8804 {
8806
8809 continue;
8810
8811 /* OK, we need info for this table */
8815 }
8817
8819 {
8820 /*
8821 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8822 * result in non-forward-compatible dumps of WHEN clauses due to
8823 * under-parenthesization.
8824 *
8825 * NB: We need to see partition triggers in case the tgenabled flag
8826 * has been changed from the parent.
8827 */
8828 appendPQExpBuffer(query,
8829 "SELECT t.tgrelid, t.tgname, "
8830 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8831 "t.tgenabled, t.tableoid, t.oid, "
8832 "t.tgparentid <> 0 AS tgispartition\n"
8833 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8834 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8835 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8836 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
8837 "OR t.tgenabled != u.tgenabled) "
8838 "ORDER BY t.tgrelid, t.tgname",
8839 tbloids->data);
8840 }
8842 {
8843 /*
8844 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8845 * result in non-forward-compatible dumps of WHEN clauses due to
8846 * under-parenthesization.
8847 *
8848 * NB: We need to see tgisinternal triggers in partitions, in case the
8849 * tgenabled flag has been changed from the parent.
8850 */
8851 appendPQExpBuffer(query,
8852 "SELECT t.tgrelid, t.tgname, "
8853 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8854 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition\n"
8855 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8856 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8857 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8858 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
8859 "ORDER BY t.tgrelid, t.tgname",
8860 tbloids->data);
8861 }
8863 {
8864 /*
8865 * NB: We need to see tgisinternal triggers in partitions, in case the
8866 * tgenabled flag has been changed from the parent. No tgparentid in
8867 * version 11-12, so we have to match them via pg_depend.
8868 *
8869 * See above about pretty=true in pg_get_triggerdef.
8870 */
8871 appendPQExpBuffer(query,
8872 "SELECT t.tgrelid, t.tgname, "
8873 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8874 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
8875 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8876 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8877 "LEFT JOIN pg_catalog.pg_depend AS d ON "
8878 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8879 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8880 " d.objid = t.oid "
8881 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
8882 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
8883 "ORDER BY t.tgrelid, t.tgname",
8884 tbloids->data);
8885 }
8886 else
8887 {
8888 /* See above about pretty=true in pg_get_triggerdef */
8889 appendPQExpBuffer(query,
8890 "SELECT t.tgrelid, t.tgname, "
8891 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8892 "t.tgenabled, false as tgispartition, "
8893 "t.tableoid, t.oid "
8894 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8895 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8896 "WHERE NOT tgisinternal "
8897 "ORDER BY t.tgrelid, t.tgname",
8898 tbloids->data);
8899 }
8900
8902
8903 ntups = PQntuples(res);
8904
8912
8914
8915 /*
8916 * Outer loop iterates once per table, not once per row. Incrementing of
8917 * j is handled by the inner loop.
8918 */
8919 curtblindx = -1;
8921 {
8925
8926 /* Count rows for this table */
8929 break;
8930
8931 /*
8932 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8933 * order.
8934 */
8936 {
8939 break;
8940 }
8943
8944 /* Save data for this table */
8947
8949 {
8960 }
8961 }
8962
8963 PQclear(res);
8964
8965 destroyPQExpBuffer(query);
8967}
8968
8969/*
8970 * getEventTriggers
8971 * get information about event triggers
8972 */
8973void
8975{
8977 PQExpBuffer query;
8978 PGresult *res;
8981 i_oid,
8982 i_evtname,
8983 i_evtevent,
8984 i_evtowner,
8985 i_evttags,
8986 i_evtfname,
8987 i_evtenabled;
8988 int ntups;
8989
8990 /* Before 9.3, there are no event triggers */
8992 return;
8993
8994 query = createPQExpBuffer();
8995
8996 appendPQExpBufferStr(query,
8997 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8998 "evtevent, evtowner, "
8999 "array_to_string(array("
9000 "select quote_literal(x) "
9001 " from unnest(evttags) as t(x)), ', ') as evttags, "
9002 "e.evtfoid::regproc as evtfname "
9003 "FROM pg_event_trigger e "
9004 "ORDER BY e.oid");
9005
9007
9008 ntups = PQntuples(res);
9009
9011
9020
9022 {
9034
9035 /* Decide whether we want to dump it */
9037 }
9038
9039 PQclear(res);
9040
9041 destroyPQExpBuffer(query);
9042}
9043
9044/*
9045 * getProcLangs
9046 * get basic information about every procedural language in the system
9047 *
9048 * NB: this must run after getFuncs() because we assume we can do
9049 * findFuncByOid().
9050 */
9051void
9053{
9054 PGresult *res;
9055 int ntups;
9069
9071 "lanname, lanpltrusted, lanplcallfoid, "
9072 "laninline, lanvalidator, "
9073 "lanacl, "
9074 "acldefault('l', lanowner) AS acldefault, "
9075 "lanowner "
9076 "FROM pg_language "
9077 "WHERE lanispl "
9078 "ORDER BY oid");
9079
9081
9082 ntups = PQntuples(res);
9083
9085
9096
9098 {
9103
9114
9115 /* Decide whether we want to dump it */
9117
9118 /* Mark whether language has an ACL */
9121 }
9122
9123 PQclear(res);
9124
9125 destroyPQExpBuffer(query);
9126}
9127
9128/*
9129 * getCasts
9130 * get basic information about most casts in the system
9131 *
9132 * Skip casts from a range to its multirange, since we'll create those
9133 * automatically.
9134 */
9135void
9137{
9138 PGresult *res;
9139 int ntups;
9150
9152 {
9154 "castsource, casttarget, castfunc, castcontext, "
9155 "castmethod "
9156 "FROM pg_cast c "
9157 "WHERE NOT EXISTS ( "
9158 "SELECT 1 FROM pg_range r "
9159 "WHERE c.castsource = r.rngtypid "
9160 "AND c.casttarget = r.rngmultitypid "
9161 ") "
9162 "ORDER BY 3,4");
9163 }
9164 else
9165 {
9167 "castsource, casttarget, castfunc, castcontext, "
9168 "castmethod "
9169 "FROM pg_cast ORDER BY 3,4");
9170 }
9171
9173
9174 ntups = PQntuples(res);
9175
9177
9185
9187 {
9191
9201
9202 /*
9203 * Try to name cast as concatenation of typnames. This is only used
9204 * for purposes of sorting. If we fail to find either type, the name
9205 * will be an empty string.
9206 */
9214
9215 /* Decide whether we want to dump it */
9217 }
9218
9219 PQclear(res);
9220
9221 destroyPQExpBuffer(query);
9222}
9223
9224static char *
9226{
9227 PQExpBuffer query;
9228 PGresult *res;
9230
9231 query = createPQExpBuffer();
9235 destroyPQExpBuffer(query);
9236 PQclear(res);
9237
9239}
9240
9241/*
9242 * getTransforms
9243 * get basic information about every transform in the system
9244 */
9245void
9247{
9248 PGresult *res;
9249 int ntups;
9251 PQExpBuffer query;
9259
9260 /* Transforms didn't exist pre-9.5 */
9262 return;
9263
9264 query = createPQExpBuffer();
9265
9267 "trftype, trflang, trffromsql::oid, trftosql::oid "
9268 "FROM pg_transform "
9269 "ORDER BY 3,4");
9270
9272
9273 ntups = PQntuples(res);
9274
9276
9283
9285 {
9289
9298
9299 /*
9300 * Try to name transform as concatenation of type and language name.
9301 * This is only used for purposes of sorting. If we fail to find
9302 * either, the name will be an empty string.
9303 */
9312
9313 /* Decide whether we want to dump it */
9315 }
9316
9317 PQclear(res);
9318
9319 destroyPQExpBuffer(query);
9320}
9321
9322/*
9323 * getTableAttrs -
9324 * for each interesting table, read info about its attributes
9325 * (names, types, default values, CHECK constraints, etc)
9326 *
9327 * modifies tblinfo
9328 */
9329void
9331{
9337 PGresult *res;
9338 int ntups;
9364
9365 /*
9366 * We want to perform just one query against pg_attribute, and then just
9367 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
9368 * (for CHECK constraints and for NOT NULL constraints). However, we
9369 * mustn't try to select every row of those catalogs and then sort it out
9370 * on the client side, because some of the server-side functions we need
9371 * would be unsafe to apply to tables we don't have lock on. Hence, we
9372 * build an array of the OIDs of tables we care about (and now have lock
9373 * on!), and use a WHERE clause to constrain which rows are selected.
9374 */
9378 {
9380
9381 /* Don't bother to collect info for sequences */
9383 continue;
9384
9385 /*
9386 * Don't bother with uninteresting tables, either. For binary
9387 * upgrades, this is bypassed for pg_largeobject_metadata and
9388 * pg_shdepend so that the columns names are collected for the
9389 * corresponding COPY commands. Restoring the data for those catalogs
9390 * is faster than restoring the equivalent set of large object
9391 * commands.
9392 */
9397 continue;
9398
9399 /* OK, we need info for this table */
9403
9405 {
9406 /* Also make a list of the ones with check constraints */
9410 }
9411 }
9414
9415 /*
9416 * Find all the user attributes and their types.
9417 *
9418 * Since we only want to dump COLLATE clauses for attributes whose
9419 * collation is different from their type's default, we use a CASE here to
9420 * suppress uninteresting attcollations cheaply.
9421 */
9422 appendPQExpBufferStr(q,
9423 "SELECT\n"
9424 "a.attrelid,\n"
9425 "a.attnum,\n"
9426 "a.attname,\n"
9427 "a.attstattarget,\n"
9428 "a.attstorage,\n"
9429 "t.typstorage,\n"
9430 "a.atthasdef,\n"
9431 "a.attisdropped,\n"
9432 "a.attlen,\n"
9433 "a.attalign,\n"
9434 "a.attislocal,\n"
9435 "pg_catalog.format_type(t.oid, a.atttypmod) AS atttypname,\n"
9436 "array_to_string(a.attoptions, ', ') AS attoptions,\n"
9437 "CASE WHEN a.attcollation <> t.typcollation "
9438 "THEN a.attcollation ELSE 0 END AS attcollation,\n"
9439 "pg_catalog.array_to_string(ARRAY("
9440 "SELECT pg_catalog.quote_ident(option_name) || "
9441 "' ' || pg_catalog.quote_literal(option_value) "
9442 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
9443 "ORDER BY option_name"
9444 "), E',\n ') AS attfdwoptions,\n");
9445
9446 /*
9447 * Find out any NOT NULL markings for each column. In 18 and up we read
9448 * pg_constraint to obtain the constraint name, and for valid constraints
9449 * also pg_description to obtain its comment. notnull_noinherit is set
9450 * according to the NO INHERIT property. For versions prior to 18, we
9451 * store an empty string as the name when a constraint is marked as
9452 * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
9453 * without a name); also, such cases are never NO INHERIT.
9454 *
9455 * For invalid constraints, we need to store their OIDs for processing
9456 * elsewhere, so we bring the pg_constraint.oid value when the constraint
9457 * is invalid, and NULL otherwise. Their comments are handled not here
9458 * but by collectComments, because they're their own dumpable object.
9459 *
9460 * We track in notnull_islocal whether the constraint was defined directly
9461 * in this table or via an ancestor, for binary upgrade. flagInhAttrs
9462 * might modify this later.
9463 */
9465 appendPQExpBufferStr(q,
9466 "co.conname AS notnull_name,\n"
9467 "CASE WHEN co.convalidated THEN pt.description"
9468 " ELSE NULL END AS notnull_comment,\n"
9469 "CASE WHEN NOT co.convalidated THEN co.oid "
9470 "ELSE NULL END AS notnull_invalidoid,\n"
9471 "co.connoinherit AS notnull_noinherit,\n"
9472 "co.conislocal AS notnull_islocal,\n");
9473 else
9474 appendPQExpBufferStr(q,
9475 "CASE WHEN a.attnotnull THEN '' ELSE NULL END AS notnull_name,\n"
9476 "NULL AS notnull_comment,\n"
9477 "NULL AS notnull_invalidoid,\n"
9478 "false AS notnull_noinherit,\n"
9479 "CASE WHEN a.attislocal THEN true\n"
9480 " WHEN a.attnotnull AND NOT a.attislocal THEN true\n"
9481 " ELSE false\n"
9482 "END AS notnull_islocal,\n");
9483
9485 appendPQExpBufferStr(q,
9486 "a.attcompression AS attcompression,\n");
9487 else
9488 appendPQExpBufferStr(q,
9489 "'' AS attcompression,\n");
9490
9492 appendPQExpBufferStr(q,
9493 "a.attidentity,\n");
9494 else
9495 appendPQExpBufferStr(q,
9496 "'' AS attidentity,\n");
9497
9499 appendPQExpBufferStr(q,
9500 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
9501 "THEN a.attmissingval ELSE null END AS attmissingval,\n");
9502 else
9503 appendPQExpBufferStr(q,
9504 "NULL AS attmissingval,\n");
9505
9507 appendPQExpBufferStr(q,
9508 "a.attgenerated\n");
9509 else
9510 appendPQExpBufferStr(q,
9511 "'' AS attgenerated\n");
9512
9513 /* need left join to pg_type to not fail on dropped columns ... */
9514 appendPQExpBuffer(q,
9515 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9516 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
9517 "LEFT JOIN pg_catalog.pg_type t "
9518 "ON (a.atttypid = t.oid)\n",
9519 tbloids->data);
9520
9521 /*
9522 * In versions 18 and up, we need pg_constraint for explicit NOT NULL
9523 * entries and pg_description to get their comments.
9524 */
9526 appendPQExpBufferStr(q,
9527 " LEFT JOIN pg_catalog.pg_constraint co ON "
9528 "(a.attrelid = co.conrelid\n"
9529 " AND co.contype = 'n' AND "
9530 "co.conkey = array[a.attnum])\n"
9531 " LEFT JOIN pg_catalog.pg_description pt ON "
9532 "(pt.classoid = co.tableoid AND pt.objoid = co.oid)\n");
9533
9534 appendPQExpBufferStr(q,
9535 "WHERE a.attnum > 0::pg_catalog.int2\n");
9536
9537 /*
9538 * For binary upgrades from <v12, be sure to pick up
9539 * pg_largeobject_metadata's oid column.
9540 */
9542 appendPQExpBufferStr(q,
9543 "OR (a.attnum = -2::pg_catalog.int2 AND src.tbloid = "
9545
9546 appendPQExpBufferStr(q,
9547 "ORDER BY a.attrelid, a.attnum");
9548
9550
9551 ntups = PQntuples(res);
9552
9577
9578 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
9581
9582 /*
9583 * Outer loop iterates once per table, not once per row. Incrementing of
9584 * r is handled by the inner loop.
9585 */
9586 curtblindx = -1;
9587 for (int r = 0; r < ntups;)
9588 {
9591 int numatts;
9593
9594 /* Count rows for this table */
9595 for (numatts = 1; numatts < ntups - r; numatts++)
9597 break;
9598
9599 /*
9600 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
9601 * order.
9602 */
9604 {
9607 break;
9608 }
9611 /* cross-check that we only got requested tables */
9613 (!tbinfo->interesting &&
9618 tbinfo->dobj.name);
9619
9620 /* Save data for this table */
9621 tbinfo->numatts = numatts;
9645
9647 {
9652 tbinfo->dobj.name);
9657 else
9663 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
9668
9669 /* Handle not-null constraint name and flags */
9672 i_notnull_name,
9673 i_notnull_comment,
9674 i_notnull_invalidoid,
9675 i_notnull_noinherit,
9676 i_notnull_islocal,
9677 &invalidnotnulloids);
9678
9689 }
9690
9692 {
9693 /* Collect OIDs of interesting tables that have defaults */
9697 }
9698 }
9699
9700 /* If invalidnotnulloids has any data, finalize it */
9703
9704 PQclear(res);
9705
9706 /*
9707 * Now get info about column defaults. This is skipped for a data-only
9708 * dump, as it is only needed for table schemas.
9709 */
9711 {
9712 AttrDefInfo *attrdefs;
9715
9717
9719
9721 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc\n"
9722 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9723 "JOIN pg_catalog.pg_attrdef a ON (src.tbloid = a.adrelid)\n"
9724 "ORDER BY a.adrelid, a.adnum",
9725 tbloids->data);
9726
9728
9731
9732 curtblindx = -1;
9734 {
9740
9741 /*
9742 * Locate the associated TableInfo; we rely on tblinfo[] being in
9743 * OID order.
9744 */
9746 {
9748 {
9751 break;
9752 }
9755 }
9756
9759 adnum, tbinfo->dobj.name);
9760
9761 /*
9762 * dropped columns shouldn't have defaults, but just in case,
9763 * ignore 'em
9764 */
9766 continue;
9767
9775
9778
9780
9781 /*
9782 * Figure out whether the default/generation expression should be
9783 * dumped as part of the main CREATE TABLE (or similar) command or
9784 * as a separate ALTER TABLE (or similar) command. The preference
9785 * is to put it into the CREATE command, but in some cases that's
9786 * not possible.
9787 */
9789 {
9790 /*
9791 * Column generation expressions cannot be dumped separately,
9792 * because there is no syntax for it. By setting separate to
9793 * false here we prevent the "default" from being processed as
9794 * its own dumpable object. Later, flagInhAttrs() will mark
9795 * it as not to be dumped at all, if possible (that is, if it
9796 * can be inherited from a parent).
9797 */
9799 }
9801 {
9802 /*
9803 * Defaults on a VIEW must always be dumped as separate ALTER
9804 * TABLE commands.
9805 */
9807 }
9809 {
9810 /* column will be suppressed, print default separately */
9812 }
9813 else
9814 {
9816 }
9817
9819 {
9820 /*
9821 * Mark the default as needing to appear before the table, so
9822 * that any dependencies it has must be emitted before the
9823 * CREATE TABLE. If this is not possible, we'll change to
9824 * "separate" mode while sorting dependencies.
9825 */
9827 attrdefs[j].dobj.dumpId);
9828 }
9829
9831 }
9832
9833 PQclear(res);
9834 }
9835
9836 /*
9837 * Get info about NOT NULL NOT VALID constraints. This is skipped for a
9838 * data-only dump, as it is only needed for table schemas.
9839 */
9841 {
9850
9852
9853 resetPQExpBuffer(q);
9854 appendPQExpBuffer(q,
9855 "SELECT c.tableoid, c.oid, conrelid, conname, "
9856 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9857 "conislocal, convalidated "
9858 "FROM unnest('%s'::pg_catalog.oid[]) AS src(conoid)\n"
9859 "JOIN pg_catalog.pg_constraint c ON (src.conoid = c.oid)\n"
9860 "ORDER BY c.conrelid, c.conname",
9861 invalidnotnulloids->data);
9862
9864
9867
9874
9875 /* As above, this loop iterates once per table, not once per row */
9876 curtblindx = -1;
9878 {
9882
9883 /* Count rows for this table */
9886 break;
9887
9888 /*
9889 * Locate the associated TableInfo; we rely on tblinfo[] being in
9890 * OID order.
9891 */
9893 {
9896 break;
9897 }
9900
9902 {
9918
9919 /*
9920 * All invalid not-null constraints must be dumped separately,
9921 * because CREATE TABLE would not create them as invalid, and
9922 * also because they must be created after potentially
9923 * violating data has been loaded.
9924 */
9926
9928 }
9929 }
9930 PQclear(res);
9931 }
9932
9933 /*
9934 * Get info about table CHECK constraints. This is skipped for a
9935 * data-only dump, as it is only needed for table schemas.
9936 */
9938 {
9948
9950
9951 resetPQExpBuffer(q);
9952 appendPQExpBuffer(q,
9953 "SELECT c.tableoid, c.oid, conrelid, conname, "
9954 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9955 "conislocal, convalidated "
9956 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9957 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
9958 "WHERE contype = 'c' "
9959 "ORDER BY c.conrelid, c.conname",
9960 checkoids->data);
9961
9963
9966
9974
9975 /* As above, this loop iterates once per table, not once per row */
9976 curtblindx = -1;
9978 {
9982
9983 /* Count rows for this table */
9986 break;
9987
9988 /*
9989 * Locate the associated TableInfo; we rely on tblinfo[] being in
9990 * OID order.
9991 */
9993 {
9996 break;
9997 }
10000
10002 {
10004 "expected %d check constraints on table \"%s\" but found %d",
10005 tbinfo->ncheck),
10008 exit_nicely(1);
10009 }
10010
10012
10014 {
10016
10032
10033 /*
10034 * An unvalidated constraint needs to be dumped separately, so
10035 * that potentially-violating existing data is loaded before
10036 * the constraint.
10037 */
10039
10041
10042 /*
10043 * Mark the constraint as needing to appear before the table
10044 * --- this is so that any other dependencies of the
10045 * constraint will be emitted before we try to create the
10046 * table. If the constraint is to be dumped separately, it
10047 * will be dumped after data is loaded anyway, so don't do it.
10048 * (There's an automatic dependency in the opposite direction
10049 * anyway, so don't need to add one manually here.)
10050 */
10054
10055 /*
10056 * We will detect later whether the constraint must be split
10057 * out from the table definition.
10058 */
10059 }
10060 }
10061
10062 PQclear(res);
10063 }
10064
10065 destroyPQExpBuffer(q);
10068}
10069
10070/*
10071 * Based on the getTableAttrs query's row corresponding to one column, set
10072 * the name and flags to handle a not-null constraint for that column in
10073 * the tbinfo struct.
10074 *
10075 * Result row 'r' is for tbinfo's attribute 'j'.
10076 *
10077 * There are four possibilities:
10078 * 1) the column has no not-null constraints. In that case, ->notnull_constrs
10079 * (the constraint name) remains NULL.
10080 * 2) The column has a constraint with no name (this is the case when
10081 * constraints come from pre-18 servers). In this case, ->notnull_constrs
10082 * is set to the empty string; dumpTableSchema will print just "NOT NULL".
10083 * 3) The column has an invalid not-null constraint. This must be treated
10084 * as a separate object (because it must be created after the table data
10085 * is loaded). So we add its OID to invalidnotnulloids for processing
10086 * elsewhere and do nothing further with it here. We distinguish this
10087 * case because the "notnull_invalidoid" column has been set to a non-NULL
10088 * value, which is the constraint OID. Valid constraints have a null OID.
10089 * 4) The column has a constraint with a known name; in that case
10090 * notnull_constrs carries that name and dumpTableSchema will print
10091 * "CONSTRAINT the_name NOT NULL". However, if the name is the default
10092 * (table_column_not_null) and there's no comment on the constraint,
10093 * there's no need to print that name in the dump, so notnull_constrs
10094 * is set to the empty string and it behaves as case 2.
10095 *
10096 * In a child table that inherits from a parent already containing NOT NULL
10097 * constraints and the columns in the child don't have their own NOT NULL
10098 * declarations, we suppress printing constraints in the child: the
10099 * constraints are acquired at the point where the child is attached to the
10100 * parent. This is tracked in ->notnull_islocal; for servers pre-18 this is
10101 * set not here but in flagInhAttrs. That flag is also used when the
10102 * constraint was validated in a child but all its parent have it as NOT
10103 * VALID.
10104 *
10105 * Any of these constraints might have the NO INHERIT bit. If so we set
10106 * ->notnull_noinh and NO INHERIT will be printed by dumpTableSchema.
10107 *
10108 * In case 4 above, the name comparison is a bit of a hack; it actually fails
10109 * to do the right thing in all but the trivial case. However, the downside
10110 * of getting it wrong is simply that the name is printed rather than
10111 * suppressed, so it's not a big deal.
10112 *
10113 * invalidnotnulloids is expected to be given as NULL; if any invalid not-null
10114 * constraints are found, it is initialized and filled with the array of
10115 * OIDs of such constraints, for later processing.
10116 */
10117static void
10126{
10128
10129 /*
10130 * If this not-null constraint is not valid, list its OID in
10131 * invalidnotnulloids and do nothing further. It'll be processed
10132 * elsewhere later.
10133 *
10134 * Because invalid not-null constraints are rare, we don't want to malloc
10135 * invalidnotnulloids until we're sure we're going it need it, which
10136 * happens here.
10137 */
10139 {
10141
10143 {
10147 }
10148 else
10150
10151 /*
10152 * Track when a parent constraint is invalid for the cases where a
10153 * child constraint has been validated independenly.
10154 */
10156
10157 /* nothing else to do */
10159 return;
10160 }
10161
10162 /*
10163 * notnull_noinh is straight from the query result. notnull_islocal also,
10164 * though flagInhAttrs may change that one later.
10165 */
10169
10170 /*
10171 * Determine a constraint name to use. If the column is not marked not-
10172 * null, we set NULL which cues ... to do nothing. An empty string says
10173 * to print an unnamed NOT NULL, and anything else is a constraint name to
10174 * use.
10175 */
10177 {
10178 /*
10179 * < 18 doesn't have not-null names, so an unnamed constraint is
10180 * sufficient.
10181 */
10184 else
10186 }
10187 else
10188 {
10191 else
10192 {
10193 /*
10194 * In binary upgrade of inheritance child tables, must have a
10195 * constraint name that we can UPDATE later; same if there's a
10196 * comment on the constraint.
10197 */
10199 !tbinfo->ispartition &&
10202 {
10205 }
10206 else
10207 {
10209
10210 /* XXX should match ChooseConstraintName better */
10216 else
10217 {
10220 }
10222 }
10223 }
10224 }
10225}
10226
10227/*
10228 * Test whether a column should be printed as part of table's CREATE TABLE.
10229 * Column number is zero-based.
10230 *
10231 * Normally this is always true, but it's false for dropped columns, as well
10232 * as those that were inherited without any local definition. (If we print
10233 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
10234 * For partitions, it's always true, because we want the partitions to be
10235 * created independently and ATTACH PARTITION used afterwards.
10236 *
10237 * In binary_upgrade mode, we must print all columns and fix the attislocal/
10238 * attisdropped state later, so as to keep control of the physical column
10239 * order.
10240 *
10241 * This function exists because there are scattered nonobvious places that
10242 * must be kept in sync with this decision.
10243 */
10244bool
10246{
10248 return true;
10250 return false;
10252}
10253
10254
10255/*
10256 * getTSParsers:
10257 * get information about all text search parsers in the system catalogs
10258 */
10259void
10261{
10262 PGresult *res;
10263 int ntups;
10265 PQExpBuffer query;
10276
10277 query = createPQExpBuffer();
10278
10279 /*
10280 * find all text search objects, including builtin ones; we filter out
10281 * system-defined objects at dump-out time.
10282 */
10283
10285 "prsstart::oid, prstoken::oid, "
10286 "prsend::oid, prsheadline::oid, prslextype::oid "
10287 "FROM pg_ts_parser");
10288
10290
10291 ntups = PQntuples(res);
10292
10294
10304
10306 {
10319
10320 /* Decide whether we want to dump it */
10322 }
10323
10324 PQclear(res);
10325
10326 destroyPQExpBuffer(query);
10327}
10328
10329/*
10330 * getTSDictionaries:
10331 * get information about all text search dictionaries in the system catalogs
10332 */
10333void
10335{
10336 PGresult *res;
10337 int ntups;
10339 PQExpBuffer query;
10348
10349 query = createPQExpBuffer();
10350
10352 "dictnamespace, dictowner, "
10353 "dicttemplate, dictinitoption "
10354 "FROM pg_ts_dict");
10355
10357
10358 ntups = PQntuples(res);
10359
10361
10369
10371 {
10383 else
10385
10386 /* Decide whether we want to dump it */
10388 }
10389
10390 PQclear(res);
10391
10392 destroyPQExpBuffer(query);
10393}
10394
10395/*
10396 * getTSTemplates:
10397 * get information about all text search templates in the system catalogs
10398 */
10399void
10401{
10402 PGresult *res;
10403 int ntups;
10405 PQExpBuffer query;
10413
10414 query = createPQExpBuffer();
10415
10417 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
10418 "FROM pg_ts_template");
10419
10421
10422 ntups = PQntuples(res);
10423
10425
10432
10434 {
10444
10445 /* Decide whether we want to dump it */
10447 }
10448
10449 PQclear(res);
10450
10451 destroyPQExpBuffer(query);
10452}
10453
10454/*
10455 * getTSConfigurations:
10456 * get information about all text search configurations
10457 */
10458void
10460{
10461 PGresult *res;
10462 int ntups;
10464 PQExpBuffer query;
10472
10473 query = createPQExpBuffer();
10474
10476 "cfgnamespace, cfgowner, cfgparser "
10477 "FROM pg_ts_config");
10478
10480
10481 ntups = PQntuples(res);
10482
10484
10491
10493 {
10503
10504 /* Decide whether we want to dump it */
10506 }
10507
10508 PQclear(res);
10509
10510 destroyPQExpBuffer(query);
10511}
10512
10513/*
10514 * getForeignDataWrappers:
10515 * get information about all foreign-data wrappers in the system catalogs
10516 */
10517void
10519{
10520 PGresult *res;
10521 int ntups;
10523 PQExpBuffer query;
10535
10536 query = createPQExpBuffer();
10537
10539 "fdwowner, "
10540 "fdwhandler::pg_catalog.regproc, "
10541 "fdwvalidator::pg_catalog.regproc, ");
10542
10545 else
10547
10548 appendPQExpBufferStr(query,
10549 "fdwacl, "
10550 "acldefault('F', fdwowner) AS acldefault, "
10551 "array_to_string(ARRAY("
10552 "SELECT quote_ident(option_name) || ' ' || "
10553 "quote_literal(option_value) "
10554 "FROM pg_options_to_table(fdwoptions) "
10555 "ORDER BY option_name"
10556 "), E',\n ') AS fdwoptions "
10557 "FROM pg_foreign_data_wrapper");
10558
10560
10561 ntups = PQntuples(res);
10562
10564
10575
10577 {
10593
10594 /* Decide whether we want to dump it */
10596
10597 /* Mark whether FDW has an ACL */
10600 }
10601
10602 PQclear(res);
10603
10604 destroyPQExpBuffer(query);
10605}
10606
10607/*
10608 * getForeignServers:
10609 * get information about all foreign servers in the system catalogs
10610 */
10611void
10613{
10614 PGresult *res;
10615 int ntups;
10617 PQExpBuffer query;
10629
10630 query = createPQExpBuffer();
10631
10633 "srvowner, "
10634 "srvfdw, srvtype, srvversion, srvacl, "
10635 "acldefault('S', srvowner) AS acldefault, "
10636 "array_to_string(ARRAY("
10637 "SELECT quote_ident(option_name) || ' ' || "
10638 "quote_literal(option_value) "
10639 "FROM pg_options_to_table(srvoptions) "
10640 "ORDER BY option_name"
10641 "), E',\n ') AS srvoptions "
10642 "FROM pg_foreign_server");
10643
10645
10646 ntups = PQntuples(res);
10647
10649
10660
10662 {
10678
10679 /* Decide whether we want to dump it */
10681
10682 /* Servers have user mappings */
10684
10685 /* Mark whether server has an ACL */
10688 }
10689
10690 PQclear(res);
10691
10692 destroyPQExpBuffer(query);
10693}
10694
10695/*
10696 * getDefaultACLs:
10697 * get information about all default ACL information in the system catalogs
10698 */
10699void
10701{
10704 PQExpBuffer query;
10705 PGresult *res;
10714 ntups;
10715
10716 query = createPQExpBuffer();
10717
10718 /*
10719 * Global entries (with defaclnamespace=0) replace the hard-wired default
10720 * ACL for their object type. We should dump them as deltas from the
10721 * default ACL, since that will be used as a starting point for
10722 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
10723 * non-global entries can only add privileges not revoke them. We must
10724 * dump those as-is (i.e., as deltas from an empty ACL).
10725 *
10726 * We can use defaclobjtype as the object type for acldefault(), except
10727 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
10728 * 's'.
10729 */
10730 appendPQExpBufferStr(query,
10731 "SELECT oid, tableoid, "
10732 "defaclrole, "
10733 "defaclnamespace, "
10734 "defaclobjtype, "
10735 "defaclacl, "
10736 "CASE WHEN defaclnamespace = 0 THEN "
10737 "acldefault(CASE WHEN defaclobjtype = 'S' "
10738 "THEN 's'::\"char\" ELSE defaclobjtype END, "
10739 "defaclrole) ELSE '{}' END AS acldefault "
10740 "FROM pg_default_acl");
10741
10743
10744 ntups = PQntuples(res);
10745
10747
10755
10757 {
10759
10764 /* cheesy ... is it worth coming up with a better object name? */
10766
10769 else
10771
10778
10779 /* Default ACLs are ACLs, of course */
10781
10782 /* Decide whether we want to dump it */
10784 }
10785
10786 PQclear(res);
10787
10788 destroyPQExpBuffer(query);
10789}
10790
10791/*
10792 * getRoleName -- look up the name of a role, given its OID
10793 *
10794 * In current usage, we don't expect failures, so error out for a bad OID.
10795 */
10796static const char *
10798{
10800
10801 /*
10802 * Do binary search to find the appropriate item.
10803 */
10805 {
10808
10809 while (low <= high)
10810 {
10812
10814 high = middle - 1;
10816 low = middle + 1;
10817 else
10819 }
10820 }
10821
10824}
10825
10826/*
10827 * collectRoleNames --
10828 *
10829 * Construct a table of all known roles.
10830 * The table is sorted by OID for speed in lookup.
10831 */
10832static void
10834{
10835 PGresult *res;
10836 const char *query;
10838
10839 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10840
10842
10844
10846
10848 {
10851 }
10852
10853 PQclear(res);
10854}
10855
10856/*
10857 * getAdditionalACLs
10858 *
10859 * We have now created all the DumpableObjects, and collected the ACL data
10860 * that appears in the directly-associated catalog entries. However, there's
10861 * more ACL-related info to collect. If any of a table's columns have ACLs,
10862 * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
10863 * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
10864 * Also, in versions having the pg_init_privs catalog, read that and load the
10865 * information into the relevant DumpableObjects.
10866 */
10867static void
10869{
10871 PGresult *res;
10872 int ntups,
10873 i;
10874
10875 /* Check for per-column ACLs */
10876 appendPQExpBufferStr(query,
10877 "SELECT DISTINCT attrelid FROM pg_attribute "
10878 "WHERE attacl IS NOT NULL");
10879
10881
10882 ntups = PQntuples(res);
10884 {
10886 TableInfo *tblinfo;
10887
10888 tblinfo = findTableByOid(relid);
10889 /* OK to ignore tables we haven't got a DumpableObject for */
10890 if (tblinfo)
10891 {
10894 }
10895 }
10896 PQclear(res);
10897
10898 /* Fetch initial-privileges data */
10900 {
10901 printfPQExpBuffer(query,
10902 "SELECT objoid, classoid, objsubid, privtype, initprivs "
10903 "FROM pg_init_privs");
10904
10906
10907 ntups = PQntuples(res);
10909 {
10915 CatalogId objId;
10916 DumpableObject *dobj;
10917
10918 objId.tableoid = classoid;
10919 objId.oid = objoid;
10920 dobj = findObjectByCatalogId(objId);
10921 /* OK to ignore entries we haven't got a DumpableObject for */
10922 if (dobj)
10923 {
10924 /* Cope with sub-object initprivs */
10925 if (objsubid != 0)
10926 {
10928 {
10929 /* For a column initprivs, set the table's ACL flags */
10932 }
10933 else
10935 classoid, objoid, objsubid);
10936 continue;
10937 }
10938
10939 /*
10940 * We ignore any pg_init_privs.initprivs entry for the public
10941 * schema, as explained in getNamespaces().
10942 */
10945 continue;
10946
10947 /* Else it had better be of a type we think has ACLs */
10956 {
10958
10961 }
10962 else
10964 classoid, objoid, objsubid);
10965 }
10966 }
10967 PQclear(res);
10968 }
10969
10970 destroyPQExpBuffer(query);
10971}
10972
10973/*
10974 * dumpCommentExtended --
10975 *
10976 * This routine is used to dump any comments associated with the
10977 * object handed to this routine. The routine takes the object type
10978 * and object name (ready to print, except for schema decoration), plus
10979 * the namespace and owner of the object (for labeling the ArchiveEntry),
10980 * plus catalog ID and subid which are the lookup key for pg_description,
10981 * plus the dump ID for the object (for setting a dependency).
10982 * If a matching pg_description entry is found, it is dumped.
10983 *
10984 * Note: in some cases, such as comments for triggers and rules, the "type"
10985 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
10986 * but it doesn't seem worth complicating the API for all callers to make
10987 * it cleaner.
10988 *
10989 * Note: although this routine takes a dumpId for dependency purposes,
10990 * that purpose is just to mark the dependency in the emitted dump file
10991 * for possible future use by pg_restore. We do NOT use it for determining
10992 * ordering of the comment in the dump file, because this routine is called
10993 * after dependency sorting occurs. This routine should be called just after
10994 * calling ArchiveEntry() for the specified object.
10995 */
10996static void
11002{
11006
11007 /* do nothing, if --no-comments is supplied */
11009 return;
11010
11011 /* Comments are schema not data ... except LO comments are data */
11013 {
11015 return;
11016 }
11017 else
11018 {
11019 /* We do dump LO comments in binary-upgrade mode */
11021 return;
11022 }
11023
11024 /* Search for comments associated with catalogId, using table */
11026 &comments);
11027
11028 /* Is there one matching the subid? */
11030 {
11032 break;
11033 comments++;
11034 ncomments--;
11035 }
11036
11038 {
11040
11041 /*
11042 * initdb creates this object with a comment. Skip dumping the
11043 * initdb-provided comment, which would complicate matters for
11044 * non-superuser use of pg_dump. When the DBA has removed initdb's
11045 * comment, replicate that.
11046 */
11048 {
11050 ncomments = 1;
11051 }
11053 ncomments = 0;
11054 }
11055
11056 /* If a comment exists, build COMMENT ON statement */
11058 {
11061
11063 if (namespace && *namespace)
11068
11070
11071 /*
11072 * We mark comments as SECTION_NONE because they really belong in the
11073 * same section as their parent, whether that is pre-data or
11074 * post-data.
11075 */
11078 .namespace = namespace,
11079 .owner = owner,
11080 .description = "COMMENT",
11081 .section = SECTION_NONE,
11082 .createStmt = query->data,
11083 .deps = &dumpId,
11084 .nDeps = 1));
11085
11086 destroyPQExpBuffer(query);
11087 destroyPQExpBuffer(tag);
11088 }
11089}
11090
11091/*
11092 * dumpComment --
11093 *
11094 * Typical simplification of the above function.
11095 */
11096static inline void
11101{
11103 catalogId, subid, dumpId, NULL);
11104}
11105
11106/*
11107 * appendNamedArgument --
11108 *
11109 * Convenience routine for constructing parameters of the form:
11110 * 'paraname', 'value'::type
11111 */
11112static void
11115{
11117
11120
11123}
11124
11125/*
11126 * fetchAttributeStats --
11127 *
11128 * Fetch next batch of attribute statistics for dumpRelationStats_dumper().
11129 */
11132{
11137 int count = 0;
11142
11143 /*
11144 * Our query for retrieving statistics for multiple relations uses WITH
11145 * ORDINALITY and multi-argument UNNEST(), both of which were introduced
11146 * in v9.4. For older versions, we resort to gathering statistics for a
11147 * single relation at a time.
11148 */
11150 max_rels = 1;
11151
11152 /* If we're just starting, set our TOC pointer. */
11153 if (!te)
11155
11156 /*
11157 * We can't easily avoid a second TOC scan for the tar format because it
11158 * writes restore.sql separately, which means we must execute the queries
11159 * twice. This feels risky, but there is no known reason it should
11160 * generate different output than the first pass. Even if it does, the
11161 * worst-case scenario is that restore.sql might have different statistics
11162 * data than the archive.
11163 */
11165 {
11168 }
11169
11173
11174 /*
11175 * Scan the TOC for the next set of relevant stats entries. We assume
11176 * that statistics are dumped in the order they are listed in the TOC.
11177 * This is perhaps not the sturdiest assumption, so we verify it matches
11178 * reality in dumpRelationStats_dumper().
11179 */
11181 {
11184 continue;
11185
11187 {
11189 char relid[32];
11190
11192 appendPGArray(relids, relid);
11193 }
11194 else
11195 {
11198 }
11199
11200 count++;
11201 }
11202
11206
11207 /* Execute the query for the next batch of relations. */
11208 if (count > 0)
11209 {
11211
11213
11215 {
11218 }
11219 else
11220 {
11225 }
11226
11228 destroyPQExpBuffer(query);
11229 }
11230
11231 destroyPQExpBuffer(relids);
11234 return res;
11235}
11236
11237/*
11238 * dumpRelationStats_dumper --
11239 *
11240 * Generate command to import stats into the relation on the new database.
11241 * This routine is called by the Archiver when it wants the statistics to be
11242 * dumped.
11243 */
11244static char *
11246{
11249 static int rownum;
11250 PQExpBuffer query;
11271
11272 /*
11273 * fetchAttributeStats() assumes that the statistics are dumped in the
11274 * order they are listed in the TOC. We verify that here for safety.
11275 */
11278
11283
11288
11289 query = createPQExpBuffer();
11291 {
11293 appendPQExpBufferStr(query,
11294 "PREPARE getAttributeStats(pg_catalog.oid[]) AS\n");
11295 else
11296 appendPQExpBufferStr(query,
11297 "PREPARE getAttributeStats(pg_catalog.name[], pg_catalog.name[]) AS\n");
11298
11299 appendPQExpBufferStr(query,
11300 "SELECT s.schemaname, s.tablename, s.attname, s.inherited, "
11301 "s.null_frac, s.avg_width, s.n_distinct, "
11302 "s.most_common_vals, s.most_common_freqs, "
11303 "s.histogram_bounds, s.correlation, "
11304 "s.most_common_elems, s.most_common_elem_freqs, "
11305 "s.elem_count_histogram, ");
11306
11308 appendPQExpBufferStr(query,
11309 "s.range_length_histogram, "
11310 "s.range_empty_frac, "
11311 "s.range_bounds_histogram ");
11312 else
11313 appendPQExpBufferStr(query,
11314 "NULL AS range_length_histogram,"
11315 "NULL AS range_empty_frac,"
11316 "NULL AS range_bounds_histogram ");
11317
11318 /*
11319 * The results must be in the order of the relations supplied in the
11320 * parameters to ensure we remain in sync as we walk through the TOC.
11321 *
11322 * For v9.4 through v18, the redundant filter clause on s.tablename =
11323 * ANY(...) seems sufficient to convince the planner to use
11324 * pg_class_relname_nsp_index, which avoids a full scan of pg_stats.
11325 * In newer versions, pg_stats returns the table OIDs, eliminating the
11326 * need for that hack.
11327 *
11328 * Our query for retrieving statistics for multiple relations uses
11329 * WITH ORDINALITY and multi-argument UNNEST(), both of which were
11330 * introduced in v9.4. For older versions, we resort to gathering
11331 * statistics for a single relation at a time.
11332 */
11334 appendPQExpBufferStr(query,
11335 "FROM pg_catalog.pg_stats s "
11336 "JOIN unnest($1) WITH ORDINALITY AS u (tableid, ord) "
11337 "ON s.tableid = u.tableid "
11338 "ORDER BY u.ord, s.attname, s.inherited");
11340 appendPQExpBufferStr(query,
11341 "FROM pg_catalog.pg_stats s "
11342 "JOIN unnest($1, $2) WITH ORDINALITY AS u (schemaname, tablename, ord) "
11343 "ON s.schemaname = u.schemaname "
11344 "AND s.tablename = u.tablename "
11345 "WHERE s.tablename = ANY($2) "
11346 "ORDER BY u.ord, s.attname, s.inherited");
11347 else
11348 appendPQExpBufferStr(query,
11349 "FROM pg_catalog.pg_stats s "
11350 "WHERE s.schemaname = $1[1] "
11351 "AND s.tablename = $2[1] "
11352 "ORDER BY s.attname, s.inherited");
11353
11355
11357 resetPQExpBuffer(query);
11358 }
11359
11360 initPQExpBuffer(out);
11361
11362 /* restore relation stats */
11373
11374 /*
11375 * Before v14, a reltuples value of 0 was ambiguous: it could either mean
11376 * the relation is empty, or it could mean that it hadn't yet been
11377 * vacuumed or analyzed. (Newer versions use -1 for the latter case.)
11378 * This ambiguity allegedly can cause the planner to choose inefficient
11379 * plans after restoring to v18 or newer. To deal with this, let's just
11380 * set reltuples to -1 in that case.
11381 */
11384 else
11386
11388 rsinfo->relallvisible);
11389
11392
11394
11395 /* Fetch the next batch of attribute statistics if needed. */
11397 {
11398 PQclear(res);
11400 rownum = 0;
11401 }
11402
11420
11421 /* restore attribute stats */
11423 {
11425
11426 /* Stop if the next stat row in our cache isn't for this relation. */
11429 break;
11430
11438
11442
11443 /*
11444 * Indexes look up attname in indAttNames to derive attnum, all others
11445 * use attname directly. We must specify attnum for indexes, since
11446 * their attnames are not necessarily stable across dump/reload.
11447 */
11449 {
11452 }
11453 else
11454 {
11455 bool found = false;
11456
11458 {
11460 {
11462 i + 1);
11463 found = true;
11464 break;
11465 }
11466 }
11467
11468 if (!found)
11470 }
11471
11506 {
11516 }
11518 }
11519
11520 destroyPQExpBuffer(query);
11522}
11523
11524/*
11525 * dumpRelationStats --
11526 *
11527 * Make an ArchiveEntry for the relation statistics. The Archiver will take
11528 * care of gathering the statistics and generating the restore commands when
11529 * they are needed.
11530 */
11531static void
11533{
11535
11536 /* nothing to do if we are not dumping statistics */
11538 return;
11539
11542 .namespace = dobj->namespace->dobj.name,
11543 .description = "STATISTICS DATA",
11544 .section = rsinfo->section,
11545 .defnFn = dumpRelationStats_dumper,
11546 .defnArg = rsinfo,
11547 .deps = dobj->dependencies,
11548 .nDeps = dobj->nDeps));
11549}
11550
11551/*
11552 * dumpTableComment --
11553 *
11554 * As above, but dump comments for both the specified table (or view)
11555 * and its columns.
11556 */
11557static void
11560{
11564 PQExpBuffer query;
11565 PQExpBuffer tag;
11566
11567 /* do nothing, if --no-comments is supplied */
11569 return;
11570
11571 /* Comments are SCHEMA not data */
11573 return;
11574
11575 /* Search for comments associated with relation, using table */
11577 tbinfo->dobj.catId.oid,
11578 &comments);
11579
11580 /* If comments exist, build COMMENT ON statements */
11582 return;
11583
11584 query = createPQExpBuffer();
11585 tag = createPQExpBuffer();
11586
11588 {
11591
11592 if (objsubid == 0)
11593 {
11594 resetPQExpBuffer(tag);
11597
11598 resetPQExpBuffer(query);
11603
11606 .namespace = tbinfo->dobj.namespace->dobj.name,
11607 .owner = tbinfo->rolname,
11608 .description = "COMMENT",
11609 .section = SECTION_NONE,
11610 .createStmt = query->data,
11611 .deps = &(tbinfo->dobj.dumpId),
11612 .nDeps = 1));
11613 }
11615 {
11616 resetPQExpBuffer(tag);
11620
11621 resetPQExpBuffer(query);
11628
11631 .namespace = tbinfo->dobj.namespace->dobj.name,
11632 .owner = tbinfo->rolname,
11633 .description = "COMMENT",
11634 .section = SECTION_NONE,
11635 .createStmt = query->data,
11636 .deps = &(tbinfo->dobj.dumpId),
11637 .nDeps = 1));
11638 }
11639
11640 comments++;
11641 ncomments--;
11642 }
11643
11644 destroyPQExpBuffer(query);
11645 destroyPQExpBuffer(tag);
11646}
11647
11648/*
11649 * findComments --
11650 *
11651 * Find the comment(s), if any, associated with the given object. All the
11652 * objsubid values associated with the given classoid/objoid are found with
11653 * one search.
11654 */
11655static int
11657{
11659 CommentItem *low;
11660 CommentItem *high;
11661 int nmatch;
11662
11663 /*
11664 * Do binary search to find some item matching the object.
11665 */
11666 low = &comments[0];
11668 while (low <= high)
11669 {
11670 middle = low + (high - low) / 2;
11671
11673 high = middle - 1;
11675 low = middle + 1;
11677 high = middle - 1;
11679 low = middle + 1;
11680 else
11681 break; /* found a match */
11682 }
11683
11684 if (low > high) /* no matches */
11685 {
11687 return 0;
11688 }
11689
11690 /*
11691 * Now determine how many items match the object. The search loop
11692 * invariant still holds: only items between low and high inclusive could
11693 * match.
11694 */
11695 nmatch = 1;
11697 {
11699 objoid != middle[-1].objoid)
11700 break;
11701 middle--;
11702 nmatch++;
11703 }
11704
11706
11707 middle += nmatch;
11709 {
11711 objoid != middle->objoid)
11712 break;
11713 middle++;
11714 nmatch++;
11715 }
11716
11717 return nmatch;
11718}
11719
11720/*
11721 * collectComments --
11722 *
11723 * Construct a table of all comments available for database objects;
11724 * also set the has-comment component flag for each relevant object.
11725 *
11726 * We used to do per-object queries for the comments, but it's much faster
11727 * to pull them all over at once, and on most databases the memory cost
11728 * isn't high.
11729 *
11730 * The table is sorted by classoid/objid/objsubid for speed in lookup.
11731 */
11732static void
11734{
11735 PGresult *res;
11736 PQExpBuffer query;
11741 int ntups;
11743 DumpableObject *dobj;
11744
11745 query = createPQExpBuffer();
11746
11748 "FROM pg_catalog.pg_description "
11749 "ORDER BY classoid, objoid, objsubid");
11750
11752
11753 /* Construct lookup table containing OIDs in numeric form */
11754
11759
11760 ntups = PQntuples(res);
11761
11763 ncomments = 0;
11764 dobj = NULL;
11765
11767 {
11768 CatalogId objId;
11769 int subid;
11770
11774
11775 /* We needn't remember comments that don't match any dumpable object */
11779 dobj = findObjectByCatalogId(objId);
11781 continue;
11782
11783 /*
11784 * Comments on columns of composite types are linked to the type's
11785 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11786 * in the type's own DumpableObject.
11787 */
11790 {
11792
11796 }
11797 else
11798 dobj->components |= DUMP_COMPONENT_COMMENT;
11799
11804 ncomments++;
11805 }
11806
11807 PQclear(res);
11808 destroyPQExpBuffer(query);
11809}
11810
11811/*
11812 * dumpDumpableObject
11813 *
11814 * This routine and its subsidiaries are responsible for creating
11815 * ArchiveEntries (TOC objects) for each object to be dumped.
11816 */
11817static void
11819{
11820 /*
11821 * Clear any dump-request bits for components that don't exist for this
11822 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
11823 * request for every kind of object.)
11824 */
11826
11827 /* Now, short-circuit if there's nothing to be done here. */
11829 return;
11830
11832 {
11835 break;
11838 break;
11841 break;
11844 break;
11847 break;
11850 break;
11853 break;
11856 break;
11859 break;
11862 break;
11865 break;
11868 break;
11871 break;
11874 break;
11877 break;
11880 break;
11883 break;
11887 break;
11890 break;
11893 break;
11896 break;
11899 break;
11902 break;
11905 break;
11908 break;
11911 break;
11914 break;
11917 break;
11920 break;
11922 /* table rowtypes and array types are never dumped separately */
11923 break;
11926 break;
11929 break;
11932 break;
11935 break;
11938 break;
11941 break;
11944 break;
11947 break;
11950 {
11952 TocEntry *te;
11953
11957 dobj->name);
11958
11961 .owner = loinfo->rolname,
11962 .description = "BLOBS",
11963 .section = SECTION_DATA,
11964 .deps = dobj->dependencies,
11965 .nDeps = dobj->nDeps,
11966 .dumpFn = dumpLOs,
11967 .dumpArg = loinfo));
11968
11969 /*
11970 * Set the TocEntry's dataLength in case we are doing a
11971 * parallel dump and want to order dump jobs by table size.
11972 * (We need some size estimate for every TocEntry with a
11973 * DataDumper function.) We don't currently have any cheap
11974 * way to estimate the size of LOs, but fortunately it doesn't
11975 * matter too much as long as we get large batches of LOs
11976 * processed reasonably early. Assume 8K per blob.
11977 */
11979 }
11980 break;
11983 break;
11986 break;
11989 break;
11993 break;
11996 break;
11999 break;
12002 break;
12005 /* never dumped, nothing to do */
12006 break;
12007 }
12008}
12009
12010/*
12011 * dumpNamespace
12012 * writes out to fout the queries to recreate a user-defined namespace
12013 */
12014static void
12016{
12018 PQExpBuffer q;
12021
12022 /* Do nothing if not dumping schema */
12024 return;
12025
12026 q = createPQExpBuffer();
12028
12030
12032 {
12035 }
12036 else
12037 {
12038 /* see selectDumpableNamespace() */
12040 "-- *not* dropping schema, since initdb creates it\n");
12041 appendPQExpBufferStr(q,
12042 "-- *not* creating schema, since initdb creates it\n");
12043 }
12044
12048
12052 .owner = nspinfo->rolname,
12053 .description = "SCHEMA",
12054 .section = SECTION_PRE_DATA,
12055 .createStmt = q->data,
12056 .dropStmt = delq->data));
12057
12058 /* Dump Schema Comments and Security Labels */
12060 {
12062
12068 initdb_comment);
12069 }
12070
12075
12080
12082
12083 destroyPQExpBuffer(q);
12085}
12086
12087/*
12088 * dumpExtension
12089 * writes out to fout the queries to recreate an extension
12090 */
12091static void
12093{
12095 PQExpBuffer q;
12098
12099 /* Do nothing if not dumping schema */
12101 return;
12102
12103 q = createPQExpBuffer();
12105
12107
12109
12111 {
12112 /*
12113 * In a regular dump, we simply create the extension, intentionally
12114 * not specifying a version, so that the destination installation's
12115 * default version is used.
12116 *
12117 * Use of IF NOT EXISTS here is unlike our behavior for other object
12118 * types; but there are various scenarios in which it's convenient to
12119 * manually create the desired extension before restoring, so we
12120 * prefer to allow it to exist already.
12121 */
12124 }
12125 else
12126 {
12127 /*
12128 * In binary-upgrade mode, it's critical to reproduce the state of the
12129 * database exactly, so our procedure is to create an empty extension,
12130 * restore all the contained objects normally, and add them to the
12131 * extension one by one. This function performs just the first of
12132 * those steps. binary_upgrade_extension_member() takes care of
12133 * adding member objects as they're created.
12134 */
12136 int n;
12137
12138 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
12139
12140 /*
12141 * We unconditionally create the extension, so we must drop it if it
12142 * exists. This could happen if the user deleted 'plpgsql' and then
12143 * readded it, causing its oid to be greater than g_last_builtin_oid.
12144 */
12146
12147 appendPQExpBufferStr(q,
12148 "SELECT pg_catalog.binary_upgrade_create_empty_extension(");
12156
12157 /*
12158 * Note that we're pushing extconfig (an OID array) back into
12159 * pg_extension exactly as-is. This is OK because pg_class OIDs are
12160 * preserved in binary upgrade.
12161 */
12164 else
12169 else
12173 n = 0;
12175 {
12177
12180 {
12181 if (n++ > 0)
12184 }
12185 }
12188 }
12189
12193 .description = "EXTENSION",
12194 .section = SECTION_PRE_DATA,
12195 .createStmt = q->data,
12196 .dropStmt = delq->data));
12197
12198 /* Dump Extension Comments */
12203
12205
12206 destroyPQExpBuffer(q);
12208}
12209
12210/*
12211 * dumpType
12212 * writes out to fout the queries to recreate a user-defined type
12213 */
12214static void
12216{
12218
12219 /* Do nothing if not dumping schema */
12221 return;
12222
12223 /* Dump out in proper style */
12236 else
12238 tyinfo->dobj.name);
12239}
12240
12241/*
12242 * dumpEnumType
12243 * writes out to fout the queries to recreate a user-defined enum type
12244 */
12245static void
12247{
12252 PGresult *res;
12253 int num,
12254 i;
12255 Oid enum_oid;
12261
12263 {
12264 /* Set up query for enum-specific details */
12265 appendPQExpBufferStr(query,
12266 "PREPARE dumpEnumType(pg_catalog.oid) AS\n"
12267 "SELECT oid, enumlabel "
12268 "FROM pg_catalog.pg_enum "
12269 "WHERE enumtypid = $1 "
12270 "ORDER BY enumsortorder");
12271
12273
12275 }
12276
12277 printfPQExpBuffer(query,
12278 "EXECUTE dumpEnumType('%u')",
12279 tyinfo->dobj.catId.oid);
12280
12282
12283 num = PQntuples(res);
12284
12287
12288 /*
12289 * CASCADE shouldn't be required here as for normal types since the I/O
12290 * functions are generic and do not get dropped.
12291 */
12293
12296 tyinfo->dobj.catId.oid,
12297 false, false);
12298
12300 qualtypname);
12301
12303 {
12305
12306 /* Labels with server-assigned oids */
12308 {
12314 }
12315 }
12316
12318
12320 {
12323
12324 /* Labels with dump-assigned (preserved) oids */
12326 {
12329
12332 appendPQExpBuffer(q,
12333 "SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
12334 enum_oid);
12338 }
12339 }
12340
12344 tyinfo->dobj.namespace->dobj.name);
12345
12349 .namespace = tyinfo->dobj.namespace->dobj.name,
12350 .owner = tyinfo->rolname,
12351 .description = "TYPE",
12352 .section = SECTION_PRE_DATA,
12353 .createStmt = q->data,
12354 .dropStmt = delq->data));
12355
12356 /* Dump Type Comments and Security Labels */
12361
12366
12370 tyinfo->dobj.namespace->dobj.name,
12372
12373 PQclear(res);
12374 destroyPQExpBuffer(q);
12376 destroyPQExpBuffer(query);
12379}
12380
12381/*
12382 * dumpRangeType
12383 * writes out to fout the queries to recreate a user-defined range type
12384 */
12385static void
12387{
12392 PGresult *res;
12396 char *procname;
12397
12399 {
12400 /* Set up query for range-specific details */
12401 appendPQExpBufferStr(query,
12402 "PREPARE dumpRangeType(pg_catalog.oid) AS\n");
12403
12404 appendPQExpBufferStr(query,
12405 "SELECT ");
12406
12408 appendPQExpBufferStr(query,
12409 "pg_catalog.format_type(rngmultitypid, NULL) AS rngmultitype, ");
12410 else
12411 appendPQExpBufferStr(query,
12412 "NULL AS rngmultitype, ");
12413
12414 appendPQExpBufferStr(query,
12415 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
12416 "opc.opcname AS opcname, "
12417 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
12418 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
12419 "opc.opcdefault, "
12420 "CASE WHEN rngcollation = st.typcollation THEN 0 "
12421 " ELSE rngcollation END AS collation, "
12422 "rngcanonical, rngsubdiff "
12423 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
12424 " pg_catalog.pg_opclass opc "
12425 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
12426 "rngtypid = $1");
12427
12429
12431 }
12432
12433 printfPQExpBuffer(query,
12434 "EXECUTE dumpRangeType('%u')",
12435 tyinfo->dobj.catId.oid);
12436
12438
12441
12442 /*
12443 * CASCADE shouldn't be required here as for normal types since the I/O
12444 * functions are generic and do not get dropped.
12445 */
12447
12450 tyinfo->dobj.catId.oid,
12451 false, true);
12452
12454 qualtypname);
12455
12458
12462
12463 /* print subtype_opclass only if not default for subtype */
12465 {
12468
12470 fmtId(nspname));
12472 }
12473
12476 {
12478
12479 if (coll)
12481 fmtQualifiedDumpable(coll));
12482 }
12483
12487
12491
12493
12497 tyinfo->dobj.namespace->dobj.name);
12498
12502 .namespace = tyinfo->dobj.namespace->dobj.name,
12503 .owner = tyinfo->rolname,
12504 .description = "TYPE",
12505 .section = SECTION_PRE_DATA,
12506 .createStmt = q->data,
12507 .dropStmt = delq->data));
12508
12509 /* Dump Type Comments and Security Labels */
12514
12519
12523 tyinfo->dobj.namespace->dobj.name,
12525
12526 PQclear(res);
12527 destroyPQExpBuffer(q);
12529 destroyPQExpBuffer(query);
12532}
12533
12534/*
12535 * dumpUndefinedType
12536 * writes out to fout the queries to recreate a !typisdefined type
12537 *
12538 * This is a shell type, but we use different terminology to distinguish
12539 * this case from where we have to emit a shell type definition to break
12540 * circular dependencies. An undefined type shouldn't ever have anything
12541 * depending on it.
12542 */
12543static void
12545{
12551
12554
12556
12559 tyinfo->dobj.catId.oid,
12560 false, false);
12561
12563 qualtypname);
12564
12568 tyinfo->dobj.namespace->dobj.name);
12569
12573 .namespace = tyinfo->dobj.namespace->dobj.name,
12574 .owner = tyinfo->rolname,
12575 .description = "TYPE",
12576 .section = SECTION_PRE_DATA,
12577 .createStmt = q->data,
12578 .dropStmt = delq->data));
12579
12580 /* Dump Type Comments and Security Labels */
12585
12590
12594 tyinfo->dobj.namespace->dobj.name,
12596
12597 destroyPQExpBuffer(q);
12601}
12602
12603/*
12604 * dumpBaseType
12605 * writes out to fout the queries to recreate a user-defined base type
12606 */
12607static void
12609{
12614 PGresult *res;
12617 char *typlen;
12619 char *typoutput;
12620 char *typreceive;
12621 char *typsend;
12625 char *typsubscript;
12634 char *typdelim;
12635 char *typbyval;
12637 char *typstorage;
12641
12643 {
12644 /* Set up query for type-specific details */
12645 appendPQExpBufferStr(query,
12646 "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
12647 "SELECT typlen, "
12648 "typinput, typoutput, typreceive, typsend, "
12649 "typreceive::pg_catalog.oid AS typreceiveoid, "
12650 "typsend::pg_catalog.oid AS typsendoid, "
12651 "typanalyze, "
12652 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
12653 "typdelim, typbyval, typalign, typstorage, "
12654 "typmodin, typmodout, "
12655 "typmodin::pg_catalog.oid AS typmodinoid, "
12656 "typmodout::pg_catalog.oid AS typmodoutoid, "
12657 "typcategory, typispreferred, "
12658 "(typcollation <> 0) AS typcollatable, "
12659 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
12660
12662 appendPQExpBufferStr(query,
12663 "typsubscript, "
12664 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
12665 else
12666 appendPQExpBufferStr(query,
12667 "'-' AS typsubscript, 0 AS typsubscriptoid ");
12668
12670 "WHERE oid = $1");
12671
12673
12675 }
12676
12677 printfPQExpBuffer(query,
12678 "EXECUTE dumpBaseType('%u')",
12679 tyinfo->dobj.catId.oid);
12680
12682
12708 {
12711 }
12712 else
12714
12717
12718 /*
12719 * The reason we include CASCADE is that the circular dependency between
12720 * the type and its I/O functions makes it impossible to drop the type any
12721 * other way.
12722 */
12724
12725 /*
12726 * We might already have a shell type, but setting pg_type_oid is
12727 * harmless, and in any case we'd better set the array type OID.
12728 */
12731 tyinfo->dobj.catId.oid,
12732 false, false);
12733
12734 appendPQExpBuffer(q,
12735 "CREATE TYPE %s (\n"
12736 " INTERNALLENGTH = %s",
12737 qualtypname,
12739
12740 /* regproc result is sufficiently quoted already */
12753
12756
12758 {
12762 else
12764 }
12765
12768
12772 zeroIsError));
12773
12775 {
12778 }
12779
12782
12784 {
12787 }
12788
12797
12806
12809
12811
12815 tyinfo->dobj.namespace->dobj.name);
12816
12820 .namespace = tyinfo->dobj.namespace->dobj.name,
12821 .owner = tyinfo->rolname,
12822 .description = "TYPE",
12823 .section = SECTION_PRE_DATA,
12824 .createStmt = q->data,
12825 .dropStmt = delq->data));
12826
12827 /* Dump Type Comments and Security Labels */
12832
12837
12841 tyinfo->dobj.namespace->dobj.name,
12843
12844 PQclear(res);
12845 destroyPQExpBuffer(q);
12847 destroyPQExpBuffer(query);
12850}
12851
12852/*
12853 * dumpDomain
12854 * writes out to fout the queries to recreate a user-defined domain
12855 */
12856static void
12858{
12863 PGresult *res;
12870 Oid typcollation;
12872
12874 {
12875 /* Set up query for domain-specific details */
12876 appendPQExpBufferStr(query,
12877 "PREPARE dumpDomain(pg_catalog.oid) AS\n");
12878
12880 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
12881 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
12882 "t.typdefault, "
12883 "CASE WHEN t.typcollation <> u.typcollation "
12884 "THEN t.typcollation ELSE 0 END AS typcollation "
12885 "FROM pg_catalog.pg_type t "
12886 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
12887 "WHERE t.oid = $1");
12888
12890
12892 }
12893
12894 printfPQExpBuffer(query,
12895 "EXECUTE dumpDomain('%u')",
12896 tyinfo->dobj.catId.oid);
12897
12899
12905 {
12908 }
12909 else
12912
12915 tyinfo->dobj.catId.oid,
12916 true, /* force array type */
12917 false); /* force multirange type */
12918
12921
12922 appendPQExpBuffer(q,
12923 "CREATE DOMAIN %s AS %s",
12924 qualtypname,
12925 typdefn);
12926
12927 /* Print collation only if different from base type's collation */
12929 {
12930 CollInfo *coll;
12931
12932 coll = findCollationByOid(typcollation);
12933 if (coll)
12935 }
12936
12937 /*
12938 * Print a not-null constraint if there's one. In servers older than 17
12939 * these don't have names, so just print it unadorned; in newer ones they
12940 * do, but most of the time it's going to be the standard generated one,
12941 * so omit the name in that case also.
12942 */
12944 {
12947 else
12948 {
12950
12952 {
12954
12955 /* XXX should match ChooseConstraintName better */
12957
12960 else
12964 }
12965 }
12966 }
12967
12969 {
12973 else
12975 }
12976
12977 PQclear(res);
12978
12979 /*
12980 * Add any CHECK constraints for the domain
12981 */
12983 {
12985
12989 }
12990
12992
12994
12998 tyinfo->dobj.namespace->dobj.name);
12999
13003 .namespace = tyinfo->dobj.namespace->dobj.name,
13004 .owner = tyinfo->rolname,
13005 .description = "DOMAIN",
13006 .section = SECTION_PRE_DATA,
13007 .createStmt = q->data,
13008 .dropStmt = delq->data));
13009
13010 /* Dump Domain Comments and Security Labels */
13015
13020
13024 tyinfo->dobj.namespace->dobj.name,
13026
13027 /* Dump any per-constraint comments */
13029 {
13032
13033 /* but only if the constraint itself was dumped here */
13035 continue;
13036
13040
13043 tyinfo->dobj.namespace->dobj.name,
13044 tyinfo->rolname,
13046
13048 }
13049
13050 /*
13051 * And a comment on the not-null constraint, if there's one -- but only if
13052 * the constraint itself was dumped here
13053 */
13055 {
13057
13060
13063 tyinfo->dobj.namespace->dobj.name,
13064 tyinfo->rolname,
13067 }
13068
13069 destroyPQExpBuffer(q);
13071 destroyPQExpBuffer(query);
13074}
13075
13076/*
13077 * dumpCompositeType
13078 * writes out to fout the queries to recreate a user-defined stand-alone
13079 * composite type
13080 */
13081static void
13083{
13089 PGresult *res;
13092 int ntups;
13101
13103 {
13104 /*
13105 * Set up query for type-specific details.
13106 *
13107 * Since we only want to dump COLLATE clauses for attributes whose
13108 * collation is different from their type's default, we use a CASE
13109 * here to suppress uninteresting attcollations cheaply. atttypid
13110 * will be 0 for dropped columns; collation does not matter for those.
13111 */
13112 appendPQExpBufferStr(query,
13113 "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
13114 "SELECT a.attname, a.attnum, "
13115 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
13116 "a.attlen, a.attalign, a.attisdropped, "
13117 "CASE WHEN a.attcollation <> at.typcollation "
13118 "THEN a.attcollation ELSE 0 END AS attcollation "
13119 "FROM pg_catalog.pg_type ct "
13120 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
13121 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
13122 "WHERE ct.oid = $1 "
13123 "ORDER BY a.attnum");
13124
13126
13128 }
13129
13130 printfPQExpBuffer(query,
13131 "EXECUTE dumpCompositeType('%u')",
13132 tyinfo->dobj.catId.oid);
13133
13135
13136 ntups = PQntuples(res);
13137
13144
13146 {
13148 tyinfo->dobj.catId.oid,
13149 false, false);
13151 }
13152
13155
13157 qualtypname);
13158
13159 actual_atts = 0;
13161 {
13166 bool attisdropped;
13167 Oid attcollation;
13168
13175
13177 continue;
13178
13179 /* Format properly if not first attr */
13183
13184 if (!attisdropped)
13185 {
13187
13188 /* Add collation if not default for the column type */
13190 {
13191 CollInfo *coll;
13192
13193 coll = findCollationByOid(attcollation);
13194 if (coll)
13196 fmtQualifiedDumpable(coll));
13197 }
13198 }
13199 else
13200 {
13201 /*
13202 * This is a dropped attribute and we're in binary_upgrade mode.
13203 * Insert a placeholder for it in the CREATE TYPE command, and set
13204 * length and alignment with direct UPDATE to the catalogs
13205 * afterwards. See similar code in dumpTableSchema().
13206 */
13208
13209 /* stash separately for insertion after the CREATE TYPE */
13210 appendPQExpBufferStr(dropped,
13211 "\n-- For binary upgrade, recreate dropped column.\n");
13213 "SET attlen = %s, "
13214 "attalign = '%s', attbyval = false\n"
13220
13222 qualtypname);
13225 }
13226 }
13229
13231
13235 tyinfo->dobj.namespace->dobj.name);
13236
13240 .namespace = tyinfo->dobj.namespace->dobj.name,
13241 .owner = tyinfo->rolname,
13242 .description = "TYPE",
13243 .section = SECTION_PRE_DATA,
13244 .createStmt = q->data,
13245 .dropStmt = delq->data));
13246
13247
13248 /* Dump Type Comments and Security Labels */
13253
13258
13262 tyinfo->dobj.namespace->dobj.name,
13264
13265 /* Dump any per-column comments */
13268
13269 PQclear(res);
13270 destroyPQExpBuffer(q);
13271 destroyPQExpBuffer(dropped);
13273 destroyPQExpBuffer(query);
13276}
13277
13278/*
13279 * dumpCompositeTypeColComments
13280 * writes out to fout the queries to recreate comments on the columns of
13281 * a user-defined stand-alone composite type.
13282 *
13283 * The caller has already made a query to collect the names and attnums
13284 * of the type's columns, so we just pass that result into here rather
13285 * than reading them again.
13286 */
13287static void
13289 PGresult *res)
13290{
13293 PQExpBuffer query;
13294 PQExpBuffer target;
13296 int ntups;
13300
13301 /* do nothing, if --no-comments is supplied */
13303 return;
13304
13305 /* Search for comments associated with type's pg_class OID */
13307 &comments);
13308
13309 /* If no comments exist, we're done */
13311 return;
13312
13313 /* Build COMMENT ON statements */
13314 query = createPQExpBuffer();
13315 target = createPQExpBuffer();
13316
13317 ntups = PQntuples(res);
13322 {
13324
13327 {
13330 {
13332 break;
13333 }
13334 }
13336 {
13338
13339 resetPQExpBuffer(target);
13343
13344 resetPQExpBuffer(query);
13350
13353 .namespace = tyinfo->dobj.namespace->dobj.name,
13354 .owner = tyinfo->rolname,
13355 .description = "COMMENT",
13356 .section = SECTION_NONE,
13357 .createStmt = query->data,
13358 .deps = &(tyinfo->dobj.dumpId),
13359 .nDeps = 1));
13360 }
13361
13362 comments++;
13363 ncomments--;
13364 }
13365
13366 destroyPQExpBuffer(query);
13367 destroyPQExpBuffer(target);
13368}
13369
13370/*
13371 * dumpShellType
13372 * writes out to fout the queries to create a shell type
13373 *
13374 * We dump a shell definition in advance of the I/O functions for the type.
13375 */
13376static void
13378{
13380 PQExpBuffer q;
13381
13382 /* Do nothing if not dumping schema */
13384 return;
13385
13386 q = createPQExpBuffer();
13387
13388 /*
13389 * Note the lack of a DROP command for the shell type; any required DROP
13390 * is driven off the base type entry, instead. This interacts with
13391 * _printTocEntry()'s use of the presence of a DROP command to decide
13392 * whether an entry needs an ALTER OWNER command. We don't want to alter
13393 * the shell type's owner immediately on creation; that should happen only
13394 * after it's filled in, otherwise the backend complains.
13395 */
13396
13399 stinfo->baseType->dobj.catId.oid,
13400 false, false);
13401
13404
13408 .namespace = stinfo->dobj.namespace->dobj.name,
13409 .owner = stinfo->baseType->rolname,
13410 .description = "SHELL TYPE",
13411 .section = SECTION_PRE_DATA,
13412 .createStmt = q->data));
13413
13414 destroyPQExpBuffer(q);
13415}
13416
13417/*
13418 * dumpProcLang
13419 * writes out to fout the queries to recreate a user-defined
13420 * procedural language
13421 */
13422static void
13424{
13433
13434 /* Do nothing if not dumping schema */
13436 return;
13437
13438 /*
13439 * Try to find the support function(s). It is not an error if we don't
13440 * find them --- if the functions are in the pg_catalog schema, as is
13441 * standard in 8.1 and up, then we won't have loaded them. (In this case
13442 * we will emit a parameterless CREATE LANGUAGE command, which will
13443 * require PL template knowledge in the backend to reload.)
13444 */
13445
13449
13451 {
13455 }
13456
13458 {
13462 }
13463
13464 /*
13465 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
13466 * parameters. Otherwise, we'll write a parameterless command, which will
13467 * be interpreted as CREATE EXTENSION.
13468 */
13472
13475
13477
13479 qlanname);
13480
13482 {
13485 qlanname);
13494 }
13495 else
13496 {
13497 /*
13498 * If not dumping parameters, then use CREATE OR REPLACE so that the
13499 * command will not fail if the language is preinstalled in the target
13500 * database.
13501 *
13502 * Modern servers will interpret this as CREATE EXTENSION IF NOT
13503 * EXISTS; perhaps we should emit that instead? But it might just add
13504 * confusion.
13505 */
13507 qlanname);
13508 }
13510
13514
13518 .owner = plang->lanowner,
13519 .description = "PROCEDURAL LANGUAGE",
13520 .section = SECTION_PRE_DATA,
13521 .createStmt = defqry->data,
13522 .dropStmt = delqry->data,
13523 ));
13524
13525 /* Dump Proc Lang Comments and Security Labels */
13530
13535
13540
13542
13545}
13546
13547/*
13548 * format_function_arguments: generate function name and argument list
13549 *
13550 * This is used when we can rely on pg_get_function_arguments to format
13551 * the argument list. Note, however, that pg_get_function_arguments
13552 * does not special-case zero-argument aggregates.
13553 */
13554static char *
13556{
13558
13563 else
13566}
13567
13568/*
13569 * format_function_signature: generate function name and argument list
13570 *
13571 * Only a minimal list of input argument types is generated; this is
13572 * sufficient to reference the function, but not to define it.
13573 *
13574 * If honor_quotes is false then the function name is never quoted.
13575 * This is appropriate for use in TOC tags, but not in SQL commands.
13576 */
13577static char *
13579{
13582
13586 else
13589 {
13592
13595 zeroIsError));
13596 }
13599}
13600
13601
13602/*
13603 * dumpFunc:
13604 * dump out one function
13605 */
13606static void
13608{
13610 PQExpBuffer query;
13611 PQExpBuffer q;
13614 PGresult *res;
13620 char *prosrc;
13627 char *prokind;
13640 const char *keyword;
13641
13642 /* Do nothing if not dumping schema */
13644 return;
13645
13646 query = createPQExpBuffer();
13647 q = createPQExpBuffer();
13650
13652 {
13653 /* Set up query for function-specific details */
13654 appendPQExpBufferStr(query,
13655 "PREPARE dumpFunc(pg_catalog.oid) AS\n");
13656
13657 appendPQExpBufferStr(query,
13658 "SELECT\n"
13659 "proretset,\n"
13660 "prosrc,\n"
13661 "probin,\n"
13662 "provolatile,\n"
13663 "proisstrict,\n"
13664 "prosecdef,\n"
13665 "lanname,\n"
13666 "proconfig,\n"
13667 "procost,\n"
13668 "prorows,\n"
13669 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
13670 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n"
13671 "pg_catalog.pg_get_function_result(p.oid) AS funcresult,\n"
13672 "proleakproof,\n");
13673
13675 appendPQExpBufferStr(query,
13676 "array_to_string(protrftypes, ' ') AS protrftypes,\n");
13677 else
13678 appendPQExpBufferStr(query,
13679 "NULL AS protrftypes,\n");
13680
13682 appendPQExpBufferStr(query,
13683 "proparallel,\n");
13684 else
13685 appendPQExpBufferStr(query,
13686 "'u' AS proparallel,\n");
13687
13689 appendPQExpBufferStr(query,
13690 "prokind,\n");
13691 else
13692 appendPQExpBufferStr(query,
13693 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind,\n");
13694
13696 appendPQExpBufferStr(query,
13697 "prosupport,\n");
13698 else
13699 appendPQExpBufferStr(query,
13700 "'-' AS prosupport,\n");
13701
13703 appendPQExpBufferStr(query,
13704 "pg_get_function_sqlbody(p.oid) AS prosqlbody\n");
13705 else
13706 appendPQExpBufferStr(query,
13707 "NULL AS prosqlbody\n");
13708
13709 appendPQExpBufferStr(query,
13710 "FROM pg_catalog.pg_proc p, pg_catalog.pg_language l\n"
13711 "WHERE p.oid = $1 "
13712 "AND l.oid = p.prolang");
13713
13715
13717 }
13718
13719 printfPQExpBuffer(query,
13720 "EXECUTE dumpFunc('%u')",
13722
13724
13727 {
13731 }
13732 else
13733 {
13734 prosrc = NULL;
13737 }
13753
13754 /*
13755 * See backend/commands/functioncmds.c for details of how the 'AS' clause
13756 * is used.
13757 */
13759 {
13761 }
13763 {
13766 if (prosrc[0] != '\0')
13767 {
13769
13770 /*
13771 * where we have bin, use dollar quoting if allowed and src
13772 * contains quote or backslash; else use regular quoting.
13773 */
13777 else
13779 }
13780 }
13781 else
13782 {
13784 /* with no bin, dollar quote src unconditionally if allowed */
13787 else
13789 }
13790
13792 {
13795 }
13796 else
13797 {
13799 nconfigitems = 0;
13800 }
13801
13804
13806
13809 funcsig);
13810
13812 keyword = "PROCEDURE";
13813 else
13814 keyword = "FUNCTION"; /* works for window functions too */
13815
13817 keyword, qual_funcsig);
13818
13820 keyword,
13823 funcsig);
13824
13826 /* no result type to output */ ;
13829 else
13833 zeroIsError));
13834
13836
13838 {
13841
13845 {
13850 }
13851
13853 }
13854
13857
13859 {
13867 }
13868
13871
13874
13877
13878 /*
13879 * COST and ROWS are emitted only if present and not default, so as not to
13880 * break backwards-compatibility of the dump without need. Keep this code
13881 * in sync with the defaults in functioncmds.c.
13882 */
13884 {
13886 {
13887 /* default cost is 1 */
13890 }
13891 else
13892 {
13893 /* default cost is 100 */
13896 }
13897 }
13901
13903 {
13904 /* We rely on regprocout to provide quoting and qualification */
13906 }
13907
13909 {
13917 }
13918
13920 {
13921 /* we feel free to scribble on configitems[] here */
13923 char *pos;
13924
13927 continue;
13928 *pos++ = '\0';
13930
13931 /*
13932 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
13933 * by flatten_set_variable_args() before they were put into the
13934 * proconfig array. However, because the quoting rules used there
13935 * aren't exactly like SQL's, we have to break the list value apart
13936 * and then quote the elements as string literals. (The elements may
13937 * be double-quoted as-is, but we can't just feed them to the SQL
13938 * parser; it would do the wrong thing with elements that are
13939 * zero-length or longer than NAMEDATALEN.) Also, we need a special
13940 * case for empty lists.
13941 *
13942 * Variables that are not so marked should just be emitted as simple
13943 * string literals. If the variable is not known to
13944 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
13945 * to use GUC_LIST_QUOTE for extension variables.
13946 */
13948 {
13951
13952 /* Parse string into list of identifiers */
13953 /* this shouldn't fail really */
13955 {
13956 /* Special case: represent an empty list as NULL */
13960 {
13964 }
13965 }
13967 }
13968 else
13970 }
13971
13973
13975 "pg_catalog.pg_proc", keyword,
13976 qual_funcsig);
13977
13980 keyword, funcsig,
13982
13987 .owner = finfo->rolname,
13988 .description = keyword,
13989 .section = finfo->postponed_def ?
13991 .createStmt = q->data,
13993
13994 /* Dump Function Comments and Security Labels */
13999
14004
14010
14011 PQclear(res);
14012
14013 destroyPQExpBuffer(query);
14014 destroyPQExpBuffer(q);
14022}
14023
14024
14025/*
14026 * Dump a user-defined cast
14027 */
14028static void
14030{
14039
14040 /* Do nothing if not dumping schema */
14042 return;
14043
14044 /* Cannot dump if we don't have the cast function's info */
14046 {
14050 cast->castfunc);
14051 }
14052
14057
14062
14065
14067 {
14070 break;
14073 break;
14076 {
14078
14079 /*
14080 * Always qualify the function name (format_function_signature
14081 * won't qualify it).
14082 */
14086 }
14087 else
14089 break;
14090 default:
14092 }
14093
14099
14102
14105
14109
14113 .description = "CAST",
14114 .section = SECTION_PRE_DATA,
14115 .createStmt = defqry->data,
14116 .dropStmt = delqry->data));
14117
14118 /* Dump Cast Comments */
14123
14128}
14129
14130/*
14131 * Dump a transform
14132 */
14133static void
14135{
14145
14146 /* Do nothing if not dumping schema */
14148 return;
14149
14150 /* Cannot dump if we don't have the transform functions' info */
14152 {
14156 transform->trffromsql);
14157 }
14159 {
14163 transform->trftosql);
14164 }
14165
14170
14173
14176
14179
14181 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
14182
14184 {
14186 {
14188
14189 /*
14190 * Always qualify the function name (format_function_signature
14191 * won't qualify it).
14192 */
14196 }
14197 else
14199 }
14200
14202 {
14205
14207 {
14209
14210 /*
14211 * Always qualify the function name (format_function_signature
14212 * won't qualify it).
14213 */
14217 }
14218 else
14220 }
14221
14223
14226
14229
14233
14237 .description = "TRANSFORM",
14238 .section = SECTION_PRE_DATA,
14239 .createStmt = defqry->data,
14240 .dropStmt = delqry->data,
14243
14244 /* Dump Transform Comments */
14249
14255}
14256
14257
14258/*
14259 * dumpOpr
14260 * write out a single operator definition
14261 */
14262static void
14264{
14266 PQExpBuffer query;
14267 PQExpBuffer q;
14270 PQExpBuffer details;
14271 PGresult *res;
14282 char *oprkind;
14283 char *oprcode;
14284 char *oprleft;
14285 char *oprright;
14294
14295 /* Do nothing if not dumping schema */
14297 return;
14298
14299 /*
14300 * some operators are invalid because they were the result of user
14301 * defining operators before commutators exist
14302 */
14304 return;
14305
14306 query = createPQExpBuffer();
14307 q = createPQExpBuffer();
14310 details = createPQExpBuffer();
14311
14313 {
14314 /* Set up query for operator-specific details */
14315 appendPQExpBufferStr(query,
14316 "PREPARE dumpOpr(pg_catalog.oid) AS\n"
14317 "SELECT oprkind, "
14318 "oprcode::pg_catalog.regprocedure, "
14319 "oprleft::pg_catalog.regtype, "
14320 "oprright::pg_catalog.regtype, "
14321 "oprcom, "
14322 "oprnegate, "
14323 "oprrest::pg_catalog.regprocedure, "
14324 "oprjoin::pg_catalog.regprocedure, "
14325 "oprcanmerge, oprcanhash "
14326 "FROM pg_catalog.pg_operator "
14327 "WHERE oid = $1");
14328
14330
14332 }
14333
14334 printfPQExpBuffer(query,
14335 "EXECUTE dumpOpr('%u')",
14336 oprinfo->dobj.catId.oid);
14337
14339
14350
14361
14362 /* In PG14 upwards postfix operator support does not exist anymore. */
14365 oprcode);
14366
14369 {
14372 }
14373
14375 oprinfo->dobj.name);
14376
14377 /*
14378 * right unary means there's a left arg and left unary means there's a
14379 * right arg. (Although the "r" case is dead code for PG14 and later,
14380 * continue to support it in case we're dumping from an old server.)
14381 */
14384 {
14387 }
14388 else
14390
14393 {
14396 }
14397 else
14399
14402 {
14405 }
14406
14409 {
14412 }
14413
14416
14419
14422 {
14425 }
14426
14429 {
14432 }
14433
14436 oprid->data);
14437
14441
14445 oprinfo->dobj.namespace->dobj.name);
14446
14450 .namespace = oprinfo->dobj.namespace->dobj.name,
14451 .owner = oprinfo->rolname,
14452 .description = "OPERATOR",
14453 .section = SECTION_PRE_DATA,
14454 .createStmt = q->data,
14455 .dropStmt = delq->data));
14456
14457 /* Dump Operator Comments */
14462
14463 PQclear(res);
14464
14465 destroyPQExpBuffer(query);
14466 destroyPQExpBuffer(q);
14469 destroyPQExpBuffer(details);
14470}
14471
14472/*
14473 * Convert a function reference obtained from pg_operator
14474 *
14475 * Returns allocated string of what to print, or NULL if function references
14476 * is InvalidOid. Returned string is expected to be free'd by the caller.
14477 *
14478 * The input is a REGPROCEDURE display; we have to strip the argument-types
14479 * part.
14480 */
14481static char *
14483{
14487
14488 /* In all cases "-" means a null reference */
14491
14493 /* find non-double-quoted left paren */
14496 {
14498 {
14500 break;
14501 }
14504 }
14506}
14507
14508/*
14509 * getFormattedOperatorName - retrieve the operator name for the
14510 * given operator OID (presented in string form).
14511 *
14512 * Returns an allocated string, or NULL if the given OID is invalid.
14513 * Caller is responsible for free'ing result string.
14514 *
14515 * What we produce has the format "OPERATOR(schema.oprname)". This is only
14516 * useful in commands where the operator's argument types can be inferred from
14517 * context. We always schema-qualify the name, though. The predecessor to
14518 * this code tried to skip the schema qualification if possible, but that led
14519 * to wrong results in corner cases, such as if an operator and its negator
14520 * are in different schemas.
14521 */
14522static char *
14524{
14526
14527 /* In all cases "0" means a null reference */
14530
14533 {
14535 oproid);
14537 }
14538
14541 oprInfo->dobj.name);
14542}
14543
14544/*
14545 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
14546 *
14547 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
14548 * argument lists of these functions are predetermined. Note that the
14549 * caller should ensure we are in the proper schema, because the results
14550 * are search path dependent!
14551 */
14552static char *
14554{
14556 char query[128];
14557 PGresult *res;
14558
14560 "SELECT '%u'::pg_catalog.regproc", funcOid);
14562
14564
14565 PQclear(res);
14566
14568}
14569
14570/*
14571 * dumpAccessMethod
14572 * write out a single access method definition
14573 */
14574static void
14576{
14578 PQExpBuffer q;
14581
14582 /* Do nothing if not dumping schema */
14584 return;
14585
14586 q = createPQExpBuffer();
14588
14590
14592
14594 {
14597 break;
14600 break;
14601 default:
14604 destroyPQExpBuffer(q);
14607 return;
14608 }
14609
14611
14613 qamname);
14614
14618
14622 .description = "ACCESS METHOD",
14623 .section = SECTION_PRE_DATA,
14624 .createStmt = q->data,
14625 .dropStmt = delq->data));
14626
14627 /* Dump Access Method Comments */
14632
14633 destroyPQExpBuffer(q);
14636}
14637
14638/*
14639 * dumpOpclass
14640 * write out a single operator class definition
14641 */
14642static void
14644{
14646 PQExpBuffer query;
14647 PQExpBuffer q;
14650 PGresult *res;
14651 int ntups;
14667 char *opcintype;
14670 char *opcfamily;
14673 char *amname;
14676 char *sortfamily;
14684
14685 /* Do nothing if not dumping schema */
14687 return;
14688
14689 query = createPQExpBuffer();
14690 q = createPQExpBuffer();
14693
14694 /* Get additional fields from the pg_opclass row */
14696 "opckeytype::pg_catalog.regtype, "
14697 "opcdefault, opcfamily, "
14698 "opfname AS opcfamilyname, "
14699 "nspname AS opcfamilynsp, "
14700 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
14701 "FROM pg_catalog.pg_opclass c "
14702 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
14703 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14704 "WHERE c.oid = '%u'::pg_catalog.oid",
14705 opcinfo->dobj.catId.oid);
14706
14708
14716
14717 /* opcintype may still be needed after we PQclear res */
14721 /* opcfamily will still be needed after we PQclear res */
14725 /* amname will still be needed after we PQclear res */
14727
14731 fmtId(amname));
14732
14733 /* Build the fixed portion of the CREATE command */
14739 opcintype,
14740 fmtId(amname));
14742 {
14746 }
14748
14750
14752 {
14754 opckeytype);
14756 }
14757
14758 PQclear(res);
14759
14760 /*
14761 * Now fetch and print the OPERATOR entries (pg_amop rows).
14762 *
14763 * Print only those opfamily members that are tied to the opclass by
14764 * pg_depend entries.
14765 */
14766 resetPQExpBuffer(query);
14768 "amopopr::pg_catalog.regoperator, "
14769 "opfname AS sortfamily, "
14770 "nspname AS sortfamilynsp "
14771 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14772 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14773 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14774 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14775 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14776 "AND refobjid = '%u'::pg_catalog.oid "
14777 "AND amopfamily = '%s'::pg_catalog.oid "
14778 "ORDER BY amopstrategy",
14779 opcinfo->dobj.catId.oid,
14780 opcfamily);
14781
14783
14784 ntups = PQntuples(res);
14785
14790
14792 {
14797
14800
14803
14805 {
14809 }
14810
14812 }
14813
14814 PQclear(res);
14815
14816 /*
14817 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14818 *
14819 * Print only those opfamily members that are tied to the opclass by
14820 * pg_depend entries.
14821 *
14822 * We print the amproclefttype/amprocrighttype even though in most cases
14823 * the backend could deduce the right values, because of the corner case
14824 * of a btree sort support function for a cross-type comparison.
14825 */
14826 resetPQExpBuffer(query);
14827
14829 "amproc::pg_catalog.regprocedure, "
14830 "amproclefttype::pg_catalog.regtype, "
14831 "amprocrighttype::pg_catalog.regtype "
14832 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14833 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14834 "AND refobjid = '%u'::pg_catalog.oid "
14835 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14836 "AND objid = ap.oid "
14837 "ORDER BY amprocnum",
14838 opcinfo->dobj.catId.oid);
14839
14841
14842 ntups = PQntuples(res);
14843
14848
14850 {
14855
14858
14860
14863
14865
14867 }
14868
14869 PQclear(res);
14870
14871 /*
14872 * If needComma is still false it means we haven't added anything after
14873 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
14874 * clause with the same datatype. This isn't sanctioned by the
14875 * documentation, but actually DefineOpClass will treat it as a no-op.
14876 */
14879
14881
14884 fmtId(amname));
14885
14889 opcinfo->dobj.namespace->dobj.name);
14890
14894 .namespace = opcinfo->dobj.namespace->dobj.name,
14895 .owner = opcinfo->rolname,
14896 .description = "OPERATOR CLASS",
14897 .section = SECTION_PRE_DATA,
14898 .createStmt = q->data,
14899 .dropStmt = delq->data));
14900
14901 /* Dump Operator Class Comments */
14906
14907 free(opcintype);
14908 free(opcfamily);
14909 free(amname);
14910 destroyPQExpBuffer(query);
14911 destroyPQExpBuffer(q);
14914}
14915
14916/*
14917 * dumpOpfamily
14918 * write out a single operator family definition
14919 *
14920 * Note: this also dumps any "loose" operator members that aren't bound to a
14921 * specific opclass within the opfamily.
14922 */
14923static void
14925{
14927 PQExpBuffer query;
14928 PQExpBuffer q;
14931 PGresult *res;
14934 int ntups;
14944 char *amname;
14947 char *sortfamily;
14955
14956 /* Do nothing if not dumping schema */
14958 return;
14959
14960 query = createPQExpBuffer();
14961 q = createPQExpBuffer();
14964
14965 /*
14966 * Fetch only those opfamily members that are tied directly to the
14967 * opfamily by pg_depend entries.
14968 */
14970 "amopopr::pg_catalog.regoperator, "
14971 "opfname AS sortfamily, "
14972 "nspname AS sortfamilynsp "
14973 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14974 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14975 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14976 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14977 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14978 "AND refobjid = '%u'::pg_catalog.oid "
14979 "AND amopfamily = '%u'::pg_catalog.oid "
14980 "ORDER BY amopstrategy",
14981 opfinfo->dobj.catId.oid,
14982 opfinfo->dobj.catId.oid);
14983
14985
14986 resetPQExpBuffer(query);
14987
14989 "amproc::pg_catalog.regprocedure, "
14990 "amproclefttype::pg_catalog.regtype, "
14991 "amprocrighttype::pg_catalog.regtype "
14992 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14993 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14994 "AND refobjid = '%u'::pg_catalog.oid "
14995 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14996 "AND objid = ap.oid "
14997 "ORDER BY amprocnum",
14998 opfinfo->dobj.catId.oid);
14999
15001
15002 /* Get additional fields from the pg_opfamily row */
15003 resetPQExpBuffer(query);
15004
15006 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
15007 "FROM pg_catalog.pg_opfamily "
15008 "WHERE oid = '%u'::pg_catalog.oid",
15009 opfinfo->dobj.catId.oid);
15010
15012
15014
15015 /* amname will still be needed after we PQclear res */
15017
15021 fmtId(amname));
15022
15023 /* Build the fixed portion of the CREATE command */
15027 fmtId(amname));
15028
15029 PQclear(res);
15030
15031 /* Do we need an ALTER to add loose members? */
15033 {
15037 fmtId(amname));
15038
15040
15041 /*
15042 * Now fetch and print the OPERATOR entries (pg_amop rows).
15043 */
15045
15050
15052 {
15057
15060
15063
15065 {
15069 }
15070
15072 }
15073
15074 /*
15075 * Now fetch and print the FUNCTION entries (pg_amproc rows).
15076 */
15078
15083
15085 {
15090
15093
15096 amproc);
15097
15099 }
15100
15102 }
15103
15106 fmtId(amname));
15107
15111 opfinfo->dobj.namespace->dobj.name);
15112
15116 .namespace = opfinfo->dobj.namespace->dobj.name,
15117 .owner = opfinfo->rolname,
15118 .description = "OPERATOR FAMILY",
15119 .section = SECTION_PRE_DATA,
15120 .createStmt = q->data,
15121 .dropStmt = delq->data));
15122
15123 /* Dump Operator Family Comments */
15128
15129 free(amname);
15132 destroyPQExpBuffer(query);
15133 destroyPQExpBuffer(q);
15136}
15137
15138/*
15139 * dumpCollation
15140 * write out a single collation definition
15141 */
15142static void
15144{
15146 PQExpBuffer query;
15147 PQExpBuffer q;
15150 PGresult *res;
15162
15163 /* Do nothing if not dumping schema */
15165 return;
15166
15167 query = createPQExpBuffer();
15168 q = createPQExpBuffer();
15170
15172
15173 /* Get collation-specific details */
15175
15177 appendPQExpBufferStr(query,
15178 "collprovider, "
15179 "collversion, ");
15180 else
15181 appendPQExpBufferStr(query,
15182 "'c' AS collprovider, "
15183 "NULL AS collversion, ");
15184
15186 appendPQExpBufferStr(query,
15187 "collisdeterministic, ");
15188 else
15189 appendPQExpBufferStr(query,
15190 "true AS collisdeterministic, ");
15191
15193 appendPQExpBufferStr(query,
15194 "colllocale, ");
15196 appendPQExpBufferStr(query,
15197 "colliculocale AS colllocale, ");
15198 else
15199 appendPQExpBufferStr(query,
15200 "NULL AS colllocale, ");
15201
15203 appendPQExpBufferStr(query,
15204 "collicurules, ");
15205 else
15206 appendPQExpBufferStr(query,
15207 "NULL AS collicurules, ");
15208
15209 appendPQExpBuffer(query,
15210 "collcollate, "
15211 "collctype "
15212 "FROM pg_catalog.pg_collation c "
15213 "WHERE c.oid = '%u'::pg_catalog.oid",
15214 collinfo->dobj.catId.oid);
15215
15217
15224
15226
15229 else
15231
15234 else
15236
15237 /*
15238 * Before version 15, collcollate and collctype were of type NAME and
15239 * non-nullable. Treat empty strings as NULL for consistency.
15240 */
15242 {
15247 }
15248
15251 else
15253
15256 else
15258
15261
15264
15273 /* to allow dumping pg_catalog; not accepted on input */
15275 else
15277 collprovider);
15278
15281
15283 {
15286
15287 /* no locale -- the default collation cannot be reloaded anyway */
15288 }
15290 {
15293
15296 fout);
15297 }
15299 {
15301 {
15304
15307 fout);
15308 }
15309 else
15310 {
15314
15317 }
15318
15320 {
15323 }
15324 }
15326 {
15329
15331 {
15334 }
15335 else
15336 {
15341 }
15342 }
15343 else
15345
15346 /*
15347 * For binary upgrade, carry over the collation version. For normal
15348 * dump/restore, omit the version, so that it is computed upon restore.
15349 */
15351 {
15353
15356 {
15358 appendStringLiteralAH(q,
15360 fout);
15361 }
15362 }
15363
15365
15369 collinfo->dobj.namespace->dobj.name);
15370
15374 .namespace = collinfo->dobj.namespace->dobj.name,
15375 .owner = collinfo->rolname,
15376 .description = "COLLATION",
15377 .section = SECTION_PRE_DATA,
15378 .createStmt = q->data,
15379 .dropStmt = delq->data));
15380
15381 /* Dump Collation Comments */
15386
15387 PQclear(res);
15388
15389 destroyPQExpBuffer(query);
15390 destroyPQExpBuffer(q);
15393}
15394
15395/*
15396 * dumpConversion
15397 * write out a single conversion definition
15398 */
15399static void
15401{
15403 PQExpBuffer query;
15404 PQExpBuffer q;
15407 PGresult *res;
15416
15417 /* Do nothing if not dumping schema */
15419 return;
15420
15421 query = createPQExpBuffer();
15422 q = createPQExpBuffer();
15424
15426
15427 /* Get conversion-specific details */
15429 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
15430 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
15431 "conproc, condefault "
15432 "FROM pg_catalog.pg_conversion c "
15433 "WHERE c.oid = '%u'::pg_catalog.oid",
15434 convinfo->dobj.catId.oid);
15435
15437
15442
15447
15450
15457 /* regproc output is already sufficiently quoted */
15459
15463 convinfo->dobj.namespace->dobj.name);
15464
15468 .namespace = convinfo->dobj.namespace->dobj.name,
15469 .owner = convinfo->rolname,
15470 .description = "CONVERSION",
15471 .section = SECTION_PRE_DATA,
15472 .createStmt = q->data,
15473 .dropStmt = delq->data));
15474
15475 /* Dump Conversion Comments */
15480
15481 PQclear(res);
15482
15483 destroyPQExpBuffer(query);
15484 destroyPQExpBuffer(q);
15487}
15488
15489/*
15490 * format_aggregate_signature: generate aggregate name and argument list
15491 *
15492 * The argument type names are qualified if needed. The aggregate name
15493 * is never qualified.
15494 */
15495static char *
15497{
15500
15504 else
15506
15509 else
15510 {
15517 zeroIsError));
15519 }
15521}
15522
15523/*
15524 * dumpAgg
15525 * write out a single aggregate definition
15526 */
15527static void
15529{
15531 PQExpBuffer query;
15532 PQExpBuffer q;
15534 PQExpBuffer details;
15538 PGresult *res;
15553 const char *aggsortop;
15556 const char *aggtranstype;
15557 const char *aggtransspace;
15564
15565 /* Do nothing if not dumping schema */
15567 return;
15568
15569 query = createPQExpBuffer();
15570 q = createPQExpBuffer();
15572 details = createPQExpBuffer();
15573
15575 {
15576 /* Set up query for aggregate-specific details */
15577 appendPQExpBufferStr(query,
15578 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15579
15580 appendPQExpBufferStr(query,
15581 "SELECT "
15582 "aggtransfn,\n"
15583 "aggfinalfn,\n"
15584 "aggtranstype::pg_catalog.regtype,\n"
15585 "agginitval,\n"
15586 "aggsortop,\n"
15587 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15588 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15589
15591 appendPQExpBufferStr(query,
15592 "aggkind,\n"
15593 "aggmtransfn,\n"
15594 "aggminvtransfn,\n"
15595 "aggmfinalfn,\n"
15596 "aggmtranstype::pg_catalog.regtype,\n"
15597 "aggfinalextra,\n"
15598 "aggmfinalextra,\n"
15599 "aggtransspace,\n"
15600 "aggmtransspace,\n"
15601 "aggminitval,\n");
15602 else
15603 appendPQExpBufferStr(query,
15604 "'n' AS aggkind,\n"
15605 "'-' AS aggmtransfn,\n"
15606 "'-' AS aggminvtransfn,\n"
15607 "'-' AS aggmfinalfn,\n"
15608 "0 AS aggmtranstype,\n"
15609 "false AS aggfinalextra,\n"
15610 "false AS aggmfinalextra,\n"
15611 "0 AS aggtransspace,\n"
15612 "0 AS aggmtransspace,\n"
15613 "NULL AS aggminitval,\n");
15614
15616 appendPQExpBufferStr(query,
15617 "aggcombinefn,\n"
15618 "aggserialfn,\n"
15619 "aggdeserialfn,\n"
15620 "proparallel,\n");
15621 else
15622 appendPQExpBufferStr(query,
15623 "'-' AS aggcombinefn,\n"
15624 "'-' AS aggserialfn,\n"
15625 "'-' AS aggdeserialfn,\n"
15626 "'u' AS proparallel,\n");
15627
15629 appendPQExpBufferStr(query,
15630 "aggfinalmodify,\n"
15631 "aggmfinalmodify\n");
15632 else
15633 appendPQExpBufferStr(query,
15634 "'0' AS aggfinalmodify,\n"
15635 "'0' AS aggmfinalmodify\n");
15636
15637 appendPQExpBufferStr(query,
15638 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15639 "WHERE a.aggfnoid = p.oid "
15640 "AND p.oid = $1");
15641
15643
15645 }
15646
15647 printfPQExpBuffer(query,
15648 "EXECUTE dumpAgg('%u')",
15649 agginfo->aggfn.dobj.catId.oid);
15650
15652
15655
15677
15678 {
15681
15686 }
15687
15689
15690 /* identify default modify flag for aggkind (must match DefineAggregate) */
15691 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
15692 /* replace omitted flags for old versions */
15697
15698 /* regproc and regtype output is already sufficiently quoted */
15700 aggtransfn, aggtranstype);
15701
15703 {
15705 aggtransspace);
15706 }
15707
15709 {
15712 }
15713
15715 {
15717 aggfinalfn);
15721 {
15723 {
15726 break;
15729 break;
15732 break;
15733 default:
15735 agginfo->aggfn.dobj.name);
15736 break;
15737 }
15738 }
15739 }
15740
15743
15746
15749
15751 {
15753 aggmtransfn,
15754 aggminvtransfn,
15755 aggmtranstype);
15756 }
15757
15759 {
15761 aggmtransspace);
15762 }
15763
15765 {
15768 }
15769
15771 {
15773 aggmfinalfn);
15777 {
15779 {
15782 break;
15785 break;
15788 break;
15789 default:
15791 agginfo->aggfn.dobj.name);
15792 break;
15793 }
15794 }
15795 }
15796
15799 {
15801 aggsortconvop);
15803 }
15804
15807
15809 {
15816 agginfo->aggfn.dobj.name);
15817 }
15818
15821 aggsig);
15822
15826
15830 agginfo->aggfn.dobj.namespace->dobj.name);
15831
15834 agginfo->aggfn.dobj.dumpId,
15837 .owner = agginfo->aggfn.rolname,
15838 .description = "AGGREGATE",
15839 .section = SECTION_PRE_DATA,
15840 .createStmt = q->data,
15841 .dropStmt = delq->data));
15842
15843 /* Dump Aggregate Comments */
15846 agginfo->aggfn.dobj.namespace->dobj.name,
15847 agginfo->aggfn.rolname,
15849
15852 agginfo->aggfn.dobj.namespace->dobj.name,
15853 agginfo->aggfn.rolname,
15855
15856 /*
15857 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
15858 * command look like a function's GRANT; in particular this affects the
15859 * syntax for zero-argument aggregates and ordered-set aggregates.
15860 */
15862
15864
15868 agginfo->aggfn.dobj.namespace->dobj.name,
15870
15874
15875 PQclear(res);
15876
15877 destroyPQExpBuffer(query);
15878 destroyPQExpBuffer(q);
15880 destroyPQExpBuffer(details);
15881}
15882
15883/*
15884 * dumpTSParser
15885 * write out a single text search parser
15886 */
15887static void
15889{
15891 PQExpBuffer q;
15894
15895 /* Do nothing if not dumping schema */
15897 return;
15898
15899 q = createPQExpBuffer();
15901
15903
15906
15918
15921
15925 prsinfo->dobj.namespace->dobj.name);
15926
15930 .namespace = prsinfo->dobj.namespace->dobj.name,
15931 .description = "TEXT SEARCH PARSER",
15932 .section = SECTION_PRE_DATA,
15933 .createStmt = q->data,
15934 .dropStmt = delq->data));
15935
15936 /* Dump Parser Comments */
15941
15942 destroyPQExpBuffer(q);
15945}
15946
15947/*
15948 * dumpTSDictionary
15949 * write out a single text search dictionary
15950 */
15951static void
15953{
15955 PQExpBuffer q;
15957 PQExpBuffer query;
15959 PGresult *res;
15960 char *nspname;
15962
15963 /* Do nothing if not dumping schema */
15965 return;
15966
15967 q = createPQExpBuffer();
15969 query = createPQExpBuffer();
15970
15972
15973 /* Fetch name and namespace of the dictionary's template */
15975 "FROM pg_ts_template p, pg_namespace n "
15976 "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
15977 dictinfo->dicttemplate);
15979 nspname = PQgetvalue(res, 0, 0);
15981
15984
15988
15989 PQclear(res);
15990
15991 /* the dictinitoption can be dumped straight into the command */
15994
15996
15999
16003 dictinfo->dobj.namespace->dobj.name);
16004
16008 .namespace = dictinfo->dobj.namespace->dobj.name,
16009 .owner = dictinfo->rolname,
16010 .description = "TEXT SEARCH DICTIONARY",
16011 .section = SECTION_PRE_DATA,
16012 .createStmt = q->data,
16013 .dropStmt = delq->data));
16014
16015 /* Dump Dictionary Comments */
16020
16021 destroyPQExpBuffer(q);
16023 destroyPQExpBuffer(query);
16025}
16026
16027/*
16028 * dumpTSTemplate
16029 * write out a single text search template
16030 */
16031static void
16033{
16035 PQExpBuffer q;
16038
16039 /* Do nothing if not dumping schema */
16041 return;
16042
16043 q = createPQExpBuffer();
16045
16047
16050
16056
16059
16063 tmplinfo->dobj.namespace->dobj.name);
16064
16068 .namespace = tmplinfo->dobj.namespace->dobj.name,
16069 .description = "TEXT SEARCH TEMPLATE",
16070 .section = SECTION_PRE_DATA,
16071 .createStmt = q->data,
16072 .dropStmt = delq->data));
16073
16074 /* Dump Template Comments */
16079
16080 destroyPQExpBuffer(q);
16083}
16084
16085/*
16086 * dumpTSConfig
16087 * write out a single text search configuration
16088 */
16089static void
16091{
16093 PQExpBuffer q;
16095 PQExpBuffer query;
16097 PGresult *res;
16098 char *nspname;
16100 int ntups,
16101 i;
16104
16105 /* Do nothing if not dumping schema */
16107 return;
16108
16109 q = createPQExpBuffer();
16111 query = createPQExpBuffer();
16112
16114
16115 /* Fetch name and namespace of the config's parser */
16117 "FROM pg_ts_parser p, pg_namespace n "
16118 "WHERE p.oid = '%u' AND n.oid = prsnamespace",
16119 cfginfo->cfgparser);
16121 nspname = PQgetvalue(res, 0, 0);
16123
16126
16129
16130 PQclear(res);
16131
16132 resetPQExpBuffer(query);
16133 appendPQExpBuffer(query,
16134 "SELECT\n"
16135 " ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t\n"
16136 " WHERE t.tokid = m.maptokentype ) AS tokenname,\n"
16137 " m.mapdict::pg_catalog.regdictionary AS dictname\n"
16138 "FROM pg_catalog.pg_ts_config_map AS m\n"
16139 "WHERE m.mapcfg = '%u'\n"
16140 "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
16142
16144 ntups = PQntuples(res);
16145
16148
16150 {
16153
16156 {
16157 /* starting a new token type, so start a new command */
16162 /* tokenname needs quoting, dictname does NOT */
16165 }
16166 else
16168 }
16169
16170 if (ntups > 0)
16172
16173 PQclear(res);
16174
16177
16181 cfginfo->dobj.namespace->dobj.name);
16182
16186 .namespace = cfginfo->dobj.namespace->dobj.name,
16187 .owner = cfginfo->rolname,
16188 .description = "TEXT SEARCH CONFIGURATION",
16189 .section = SECTION_PRE_DATA,
16190 .createStmt = q->data,
16191 .dropStmt = delq->data));
16192
16193 /* Dump Configuration Comments */
16198
16199 destroyPQExpBuffer(q);
16201 destroyPQExpBuffer(query);
16203}
16204
16205/*
16206 * dumpForeignDataWrapper
16207 * write out a single foreign-data wrapper definition
16208 */
16209static void
16211{
16213 PQExpBuffer q;
16216
16217 /* Do nothing if not dumping schema */
16219 return;
16220
16221 q = createPQExpBuffer();
16223
16225
16227 qfdwname);
16228
16231
16234
16237
16240
16242
16244 qfdwname);
16245
16249 NULL);
16250
16254 .owner = fdwinfo->rolname,
16255 .description = "FOREIGN DATA WRAPPER",
16256 .section = SECTION_PRE_DATA,
16257 .createStmt = q->data,
16258 .dropStmt = delq->data));
16259
16260 /* Dump Foreign Data Wrapper Comments */
16265
16266 /* Handle the ACL */
16271
16273
16274 destroyPQExpBuffer(q);
16276}
16277
16278/*
16279 * dumpForeignServer
16280 * write out a foreign server definition
16281 */
16282static void
16284{
16286 PQExpBuffer q;
16288 PQExpBuffer query;
16289 PGresult *res;
16291 char *fdwname;
16292
16293 /* Do nothing if not dumping schema */
16295 return;
16296
16297 q = createPQExpBuffer();
16299 query = createPQExpBuffer();
16300
16302
16303 /* look up the foreign-data wrapper */
16305 "FROM pg_foreign_data_wrapper w "
16306 "WHERE w.oid = '%u'",
16307 srvinfo->srvfdw);
16309 fdwname = PQgetvalue(res, 0, 0);
16310
16313 {
16316 }
16318 {
16321 }
16322
16325
16328
16330
16332 qsrvname);
16333
16337
16341 .owner = srvinfo->rolname,
16342 .description = "SERVER",
16343 .section = SECTION_PRE_DATA,
16344 .createStmt = q->data,
16345 .dropStmt = delq->data));
16346
16347 /* Dump Foreign Server Comments */
16352
16353 /* Handle the ACL */
16358
16359 /* Dump user mappings */
16363 srvinfo->rolname,
16365
16366 PQclear(res);
16367
16369
16370 destroyPQExpBuffer(q);
16372 destroyPQExpBuffer(query);
16373}
16374
16375/*
16376 * dumpUserMappings
16377 *
16378 * This routine is used to dump any user mappings associated with the
16379 * server handed to this routine. Should be called after ArchiveEntry()
16380 * for the server.
16381 */
16382static void
16384 const char *servername, const char *namespace,
16385 const char *owner,
16387{
16388 PQExpBuffer q;
16390 PQExpBuffer query;
16391 PQExpBuffer tag;
16392 PGresult *res;
16393 int ntups;
16397
16398 q = createPQExpBuffer();
16399 tag = createPQExpBuffer();
16401 query = createPQExpBuffer();
16402
16403 /*
16404 * We read from the publicly accessible view pg_user_mappings, so as not
16405 * to fail if run by a non-superuser. Note that the view will show
16406 * umoptions as null if the user hasn't got privileges for the associated
16407 * server; this means that pg_dump will dump such a mapping, but with no
16408 * OPTIONS clause. A possible alternative is to skip such mappings
16409 * altogether, but it's not clear that that's an improvement.
16410 */
16411 appendPQExpBuffer(query,
16412 "SELECT usename, "
16413 "array_to_string(ARRAY("
16414 "SELECT quote_ident(option_name) || ' ' || "
16415 "quote_literal(option_value) "
16416 "FROM pg_options_to_table(umoptions) "
16417 "ORDER BY option_name"
16418 "), E',\n ') AS umoptions "
16419 "FROM pg_user_mappings "
16420 "WHERE srvid = '%u' "
16421 "ORDER BY usename",
16422 catalogId.oid);
16423
16425
16426 ntups = PQntuples(res);
16429
16431 {
16434
16437
16438 resetPQExpBuffer(q);
16441
16444
16446
16450
16451 resetPQExpBuffer(tag);
16453 usename, servername);
16454
16457 .namespace = namespace,
16458 .owner = owner,
16459 .description = "USER MAPPING",
16460 .section = SECTION_PRE_DATA,
16461 .createStmt = q->data,
16462 .dropStmt = delq->data));
16463 }
16464
16465 PQclear(res);
16466
16467 destroyPQExpBuffer(query);
16469 destroyPQExpBuffer(tag);
16470 destroyPQExpBuffer(q);
16471}
16472
16473/*
16474 * Write out default privileges information
16475 */
16476static void
16478{
16480 PQExpBuffer q;
16481 PQExpBuffer tag;
16483
16484 /* Do nothing if not dumping schema, or if we're skipping ACLs */
16486 return;
16487
16488 q = createPQExpBuffer();
16489 tag = createPQExpBuffer();
16490
16492 {
16495 break;
16498 break;
16501 break;
16504 break;
16507 break;
16510 break;
16511 default:
16512 /* shouldn't get here */
16516 }
16517
16519
16520 /* build the actual command(s) for this tuple */
16524 daclinfo->dacl.acl,
16526 daclinfo->defaclrole,
16527 fout->remoteVersion,
16528 q))
16530 daclinfo->dacl.acl);
16531
16535 .namespace = daclinfo->dobj.namespace ?
16537 .owner = daclinfo->defaclrole,
16539 .section = SECTION_POST_DATA,
16540 .createStmt = q->data));
16541
16542 destroyPQExpBuffer(tag);
16543 destroyPQExpBuffer(q);
16544}
16545
16546/*----------
16547 * Write out grant/revoke information
16548 *
16549 * 'objDumpId' is the dump ID of the underlying object.
16550 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
16551 * or InvalidDumpId if there is no need for a second dependency.
16552 * 'type' must be one of
16553 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
16554 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
16555 * 'name' is the formatted name of the object. Must be quoted etc. already.
16556 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
16557 * (Currently we assume that subname is only provided for table columns.)
16558 * 'nspname' is the namespace the object is in (NULL if none).
16559 * 'tag' is the tag to use for the ACL TOC entry; typically, this is NULL
16560 * to use the default for the object type.
16561 * 'owner' is the owner, NULL if there is no owner (for languages).
16562 * 'dacl' is the DumpableAcl struct for the object.
16563 *
16564 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
16565 * no ACL entry was created.
16566 *----------
16567 */
16571 const char *nspname, const char *tag, const char *owner,
16573{
16581 PQExpBuffer sql;
16582
16583 /* Do nothing if ACL dump is not enabled */
16586
16587 /* --data-only skips ACLs *except* large object ACLs */
16590
16591 sql = createPQExpBuffer();
16592
16593 /*
16594 * In binary upgrade mode, we don't run an extension's script but instead
16595 * dump out the objects independently and then recreate them. To preserve
16596 * any initial privileges which were set on extension objects, we need to
16597 * compute the set of GRANT and REVOKE commands necessary to get from the
16598 * default privileges of an object to its initial privileges as recorded
16599 * in pg_init_privs.
16600 *
16601 * At restore time, we apply these commands after having called
16602 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16603 * copy the results into pg_init_privs. This is how we preserve the
16604 * contents of that catalog across binary upgrades.
16605 */
16607 initprivs && *initprivs != '\0')
16608 {
16611 initprivs, acldefault, owner,
16615 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16616 }
16617
16618 /*
16619 * Now figure the GRANT and REVOKE commands needed to get to the object's
16620 * actual current ACL, starting from the initprivs if given, else from the
16621 * object-type-specific default. Also, while buildACLCommands will assume
16622 * that a NULL/empty acls string means it needn't do anything, what that
16623 * actually represents is the object-type-specific default; so we need to
16624 * substitute the acldefault string to get the right results in that case.
16625 */
16626 if (initprivs && *initprivs != '\0')
16627 {
16628 baseacls = initprivs;
16631 }
16632 else
16634
16640
16642 {
16645 int nDeps = 0;
16646
16647 if (tag)
16651 else
16653
16657
16659
16662 .namespace = nspname,
16663 .owner = owner,
16664 .description = "ACL",
16665 .section = SECTION_NONE,
16666 .createStmt = sql->data,
16667 .deps = aclDeps,
16668 .nDeps = nDeps));
16669
16671 }
16672
16673 destroyPQExpBuffer(sql);
16674
16676}
16677
16678/*
16679 * dumpSecLabel
16680 *
16681 * This routine is used to dump any security labels associated with the
16682 * object handed to this routine. The routine takes the object type
16683 * and object name (ready to print, except for schema decoration), plus
16684 * the namespace and owner of the object (for labeling the ArchiveEntry),
16685 * plus catalog ID and subid which are the lookup key for pg_seclabel,
16686 * plus the dump ID for the object (for setting a dependency).
16687 * If a matching pg_seclabel entry is found, it is dumped.
16688 *
16689 * Note: although this routine takes a dumpId for dependency purposes,
16690 * that purpose is just to mark the dependency in the emitted dump file
16691 * for possible future use by pg_restore. We do NOT use it for determining
16692 * ordering of the label in the dump file, because this routine is called
16693 * after dependency sorting occurs. This routine should be called just after
16694 * calling ArchiveEntry() for the specified object.
16695 */
16696static void
16698 const char *namespace, const char *owner,
16700{
16702 SecLabelItem *labels;
16705 PQExpBuffer query;
16706
16707 /* do nothing, if --no-security-labels is supplied */
16709 return;
16710
16711 /*
16712 * Security labels are schema not data ... except large object labels are
16713 * data
16714 */
16716 {
16718 return;
16719 }
16720 else
16721 {
16722 /* We do dump large object security labels in binary-upgrade mode */
16724 return;
16725 }
16726
16727 /* Search for security labels associated with catalogId, using table */
16729
16730 query = createPQExpBuffer();
16731
16733 {
16734 /*
16735 * Ignore label entries for which the subid doesn't match.
16736 */
16738 continue;
16739
16740 appendPQExpBuffer(query,
16741 "SECURITY LABEL FOR %s ON %s ",
16743 if (namespace && *namespace)
16748 }
16749
16751 {
16753
16757 .namespace = namespace,
16758 .owner = owner,
16759 .description = "SECURITY LABEL",
16760 .section = SECTION_NONE,
16761 .createStmt = query->data,
16762 .deps = &dumpId,
16763 .nDeps = 1));
16764 destroyPQExpBuffer(tag);
16765 }
16766
16767 destroyPQExpBuffer(query);
16768}
16769
16770/*
16771 * dumpTableSecLabel
16772 *
16773 * As above, but dump security label for both the specified table (or view)
16774 * and its columns.
16775 */
16776static void
16778{
16780 SecLabelItem *labels;
16783 PQExpBuffer query;
16784 PQExpBuffer target;
16785
16786 /* do nothing, if --no-security-labels is supplied */
16788 return;
16789
16790 /* SecLabel are SCHEMA not data */
16792 return;
16793
16794 /* Search for comments associated with relation, using table */
16796 tbinfo->dobj.catId.oid,
16797 &labels);
16798
16799 /* If security labels exist, build SECURITY LABEL statements */
16801 return;
16802
16803 query = createPQExpBuffer();
16804 target = createPQExpBuffer();
16805
16807 {
16808 const char *colname;
16812
16813 resetPQExpBuffer(target);
16814 if (objsubid == 0)
16815 {
16818 }
16819 else
16820 {
16822 /* first fmtXXX result must be consumed before calling again */
16826 }
16831 }
16833 {
16834 resetPQExpBuffer(target);
16839 .namespace = tbinfo->dobj.namespace->dobj.name,
16840 .owner = tbinfo->rolname,
16841 .description = "SECURITY LABEL",
16842 .section = SECTION_NONE,
16843 .createStmt = query->data,
16844 .deps = &(tbinfo->dobj.dumpId),
16845 .nDeps = 1));
16846 }
16847 destroyPQExpBuffer(query);
16848 destroyPQExpBuffer(target);
16849}
16850
16851/*
16852 * findSecLabels
16853 *
16854 * Find the security label(s), if any, associated with the given object.
16855 * All the objsubid values associated with the given classoid/objoid are
16856 * found with one search.
16857 */
16858static int
16860{
16862 SecLabelItem *low;
16863 SecLabelItem *high;
16864 int nmatch;
16865
16867 {
16869 return 0;
16870 }
16871
16872 /*
16873 * Do binary search to find some item matching the object.
16874 */
16875 low = &seclabels[0];
16877 while (low <= high)
16878 {
16879 middle = low + (high - low) / 2;
16880
16882 high = middle - 1;
16884 low = middle + 1;
16886 high = middle - 1;
16888 low = middle + 1;
16889 else
16890 break; /* found a match */
16891 }
16892
16893 if (low > high) /* no matches */
16894 {
16896 return 0;
16897 }
16898
16899 /*
16900 * Now determine how many items match the object. The search loop
16901 * invariant still holds: only items between low and high inclusive could
16902 * match.
16903 */
16904 nmatch = 1;
16906 {
16908 objoid != middle[-1].objoid)
16909 break;
16910 middle--;
16911 nmatch++;
16912 }
16913
16915
16916 middle += nmatch;
16918 {
16920 objoid != middle->objoid)
16921 break;
16922 middle++;
16923 nmatch++;
16924 }
16925
16926 return nmatch;
16927}
16928
16929/*
16930 * collectSecLabels
16931 *
16932 * Construct a table of all security labels available for database objects;
16933 * also set the has-seclabel component flag for each relevant object.
16934 *
16935 * The table is sorted by classoid/objid/objsubid for speed in lookup.
16936 */
16937static void
16939{
16940 PGresult *res;
16941 PQExpBuffer query;
16947 int ntups;
16949 DumpableObject *dobj;
16950
16951 query = createPQExpBuffer();
16952
16953 appendPQExpBufferStr(query,
16954 "SELECT label, provider, classoid, objoid, objsubid "
16955 "FROM pg_catalog.pg_seclabels "
16956 "ORDER BY classoid, objoid, objsubid");
16957
16959
16960 /* Construct lookup table containing OIDs in numeric form */
16966
16967 ntups = PQntuples(res);
16968
16970 nseclabels = 0;
16971 dobj = NULL;
16972
16974 {
16975 CatalogId objId;
16976 int subid;
16977
16981
16982 /* We needn't remember labels that don't match any dumpable object */
16986 dobj = findObjectByCatalogId(objId);
16988 continue;
16989
16990 /*
16991 * Labels on columns of composite types are linked to the type's
16992 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16993 * in the type's own DumpableObject.
16994 */
16997 {
16999
17003 }
17004 else
17005 dobj->components |= DUMP_COMPONENT_SECLABEL;
17006
17012 nseclabels++;
17013 }
17014
17015 PQclear(res);
17016 destroyPQExpBuffer(query);
17017}
17018
17019/*
17020 * dumpTable
17021 * write out to fout the declarations (not data) of a user-defined table
17022 */
17023static void
17025{
17029
17030 /* Do nothing if not dumping schema */
17032 return;
17033
17035 {
17038 else
17040 }
17041
17042 /* Handle the ACL here */
17045 {
17046 const char *objtype;
17047
17049 {
17051 objtype = "SEQUENCE";
17052 break;
17054 objtype = "PROPERTY GRAPH";
17055 break;
17056 default:
17057 objtype = "TABLE";
17058 break;
17059 }
17060
17061 tableAclDumpId =
17064 tbinfo->dobj.namespace->dobj.name,
17066 }
17067
17068 /*
17069 * Handle column ACLs, if any. Note: we pull these with a separate query
17070 * rather than trying to fetch them during getTableAttrs, so that we won't
17071 * miss ACLs on system columns. Doing it this way also allows us to dump
17072 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
17073 */
17075 {
17077 PGresult *res;
17079
17081 {
17082 /* Set up query for column ACLs */
17083 appendPQExpBufferStr(query,
17084 "PREPARE getColumnACLs(pg_catalog.oid) AS\n");
17085
17087 {
17088 /*
17089 * In principle we should call acldefault('c', relowner) to
17090 * get the default ACL for a column. However, we don't
17091 * currently store the numeric OID of the relowner in
17092 * TableInfo. We could convert the owner name using regrole,
17093 * but that creates a risk of failure due to concurrent role
17094 * renames. Given that the default ACL for columns is empty
17095 * and is likely to stay that way, it's not worth extra cycles
17096 * and risk to avoid hard-wiring that knowledge here.
17097 */
17098 appendPQExpBufferStr(query,
17099 "SELECT at.attname, "
17100 "at.attacl, "
17101 "'{}' AS acldefault, "
17102 "pip.privtype, pip.initprivs "
17103 "FROM pg_catalog.pg_attribute at "
17104 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
17105 "(at.attrelid = pip.objoid "
17106 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
17107 "AND at.attnum = pip.objsubid) "
17108 "WHERE at.attrelid = $1 AND "
17109 "NOT at.attisdropped "
17110 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
17111 "ORDER BY at.attnum");
17112 }
17113 else
17114 {
17115 appendPQExpBufferStr(query,
17116 "SELECT attname, attacl, '{}' AS acldefault, "
17117 "NULL AS privtype, NULL AS initprivs "
17118 "FROM pg_catalog.pg_attribute "
17119 "WHERE attrelid = $1 AND NOT attisdropped "
17120 "AND attacl IS NOT NULL "
17121 "ORDER BY attnum");
17122 }
17123
17125
17127 }
17128
17129 printfPQExpBuffer(query,
17130 "EXECUTE getColumnACLs('%u')",
17131 tbinfo->dobj.catId.oid);
17132
17134
17136 {
17144
17147 coldacl.privtype = privtype;
17148 coldacl.initprivs = initprivs;
17150
17151 /*
17152 * Column's GRANT type is always TABLE. Each column ACL depends
17153 * on the table-level ACL, since we can restore column ACLs in
17154 * parallel but the table-level ACL has to be done first.
17155 */
17158 tbinfo->dobj.namespace->dobj.name,
17161 }
17162 PQclear(res);
17163 destroyPQExpBuffer(query);
17164 }
17165
17167}
17168
17169/*
17170 * Create the AS clause for a view or materialized view. The semicolon is
17171 * stripped because a materialized view must add a WITH NO DATA clause.
17172 *
17173 * This returns a new buffer which must be freed by the caller.
17174 */
17177{
17180 PGresult *res;
17182
17183 /* Fetch the view definition */
17184 appendPQExpBuffer(query,
17185 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
17186 tbinfo->dobj.catId.oid);
17187
17189
17191 {
17194 tbinfo->dobj.name);
17195 else
17197 tbinfo->dobj.name);
17198 }
17199
17201
17204 tbinfo->dobj.name);
17205
17206 /* Strip off the trailing semicolon so that other things may follow. */
17209
17210 PQclear(res);
17211 destroyPQExpBuffer(query);
17212
17214}
17215
17216/*
17217 * Create a dummy AS clause for a view. This is used when the real view
17218 * definition has to be postponed because of circular dependencies.
17219 * We must duplicate the view's external properties -- column names and types
17220 * (including collation) -- so that it works for subsequent references.
17221 *
17222 * This returns a new buffer which must be freed by the caller.
17223 */
17226{
17229
17231
17233 {
17237
17239
17240 /*
17241 * Must add collation if not default for the type, because CREATE OR
17242 * REPLACE VIEW won't change it
17243 */
17245 {
17246 CollInfo *coll;
17247
17249 if (coll)
17251 fmtQualifiedDumpable(coll));
17252 }
17253
17255 }
17256
17258}
17259
17260/*
17261 * dumpTableSchema
17262 * write the declaration (not data) of one user-defined table or view
17263 */
17264static void
17266{
17273 int numParents;
17274 TableInfo **parents;
17279 k;
17280
17281 /* We had better have loaded per-column details about this table */
17283
17286
17289 qrelname);
17290
17293
17294 /* Is it a table or a view? */
17296 {
17298
17299 /*
17300 * Note: keep this code in sync with the is_view case in dumpRule()
17301 */
17302
17304
17307 tbinfo->dobj.catId.oid);
17308
17310
17313 else
17314 {
17316 {
17320 }
17322 }
17325
17329 }
17331 {
17333 PGresult *res;
17335
17337
17340 tbinfo->dobj.catId.oid);
17341
17342 appendPQExpBuffer(query,
17343 "SELECT pg_catalog.pg_get_propgraphdef('%u'::pg_catalog.oid) AS pgdef",
17344 tbinfo->dobj.catId.oid);
17345
17347
17349 {
17352 tbinfo->dobj.name);
17353 else
17354 pg_fatal("query to obtain definition of property graph \"%s\" returned more than one definition",
17355 tbinfo->dobj.name);
17356 }
17357
17359
17362 tbinfo->dobj.name);
17363
17365
17366 PQclear(res);
17367 destroyPQExpBuffer(query);
17368
17370 }
17371 else
17372 {
17377
17378 /*
17379 * Set reltypename, and collect any relkind-specific data that we
17380 * didn't fetch during getTables().
17381 */
17383 {
17385 {
17387 PGresult *res;
17388
17390
17391 /* retrieve partition key definition */
17392 appendPQExpBuffer(query,
17393 "SELECT pg_get_partkeydef('%u')",
17394 tbinfo->dobj.catId.oid);
17397 PQclear(res);
17398 destroyPQExpBuffer(query);
17399 break;
17400 }
17402 {
17404 PGresult *res;
17407
17409
17410 /* retrieve name of foreign server and generic options */
17411 appendPQExpBuffer(query,
17412 "SELECT fs.srvname, "
17413 "pg_catalog.array_to_string(ARRAY("
17414 "SELECT pg_catalog.quote_ident(option_name) || "
17415 "' ' || pg_catalog.quote_literal(option_value) "
17416 "FROM pg_catalog.pg_options_to_table(ftoptions) "
17417 "ORDER BY option_name"
17418 "), E',\n ') AS ftoptions "
17419 "FROM pg_catalog.pg_foreign_table ft "
17420 "JOIN pg_catalog.pg_foreign_server fs "
17421 "ON (fs.oid = ft.ftserver) "
17422 "WHERE ft.ftrelid = '%u'",
17423 tbinfo->dobj.catId.oid);
17429 PQclear(res);
17430 destroyPQExpBuffer(query);
17431
17433 break;
17434 }
17437 break;
17438 default:
17440 break;
17441 }
17442
17443 numParents = tbinfo->numParents;
17445
17448 tbinfo->dobj.catId.oid);
17449
17450 /*
17451 * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
17452 * ignore it when dumping if it was set in this case.
17453 */
17457 "UNLOGGED " : "",
17458 reltypename,
17459 qualrelname);
17460
17461 /*
17462 * Attach to type, if reloftype; except in case of a binary upgrade,
17463 * we dump the table normally and attach it to the type afterward.
17464 */
17468 zeroIsError));
17469
17471 {
17472 /* Dump the attributes */
17473 actual_atts = 0;
17475 {
17476 /*
17477 * Normally, dump if it's locally defined in this table, and
17478 * not dropped. But for binary upgrade, we'll dump all the
17479 * columns, and then fix up the dropped and nonlocal cases
17480 * below.
17481 */
17483 {
17486
17487 /*
17488 * Default value --- suppress if to be printed separately
17489 * or not at all.
17490 */
17494
17495 /*
17496 * Not Null constraint --- print it if it is locally
17497 * defined, or if binary upgrade. (In the latter case, we
17498 * reset conislocal below.)
17499 */
17502 dopt->binary_upgrade ||
17503 tbinfo->ispartition));
17504
17505 /*
17506 * Skip column if fully defined by reloftype, except in
17507 * binary upgrade
17508 */
17511 !dopt->binary_upgrade)
17512 continue;
17513
17514 /* Format properly if not first attr */
17517 else
17520 actual_atts++;
17521
17522 /* Attribute name */
17524
17526 {
17527 /*
17528 * ALTER TABLE DROP COLUMN clears
17529 * pg_attribute.atttypid, so we will not have gotten a
17530 * valid type name; insert INTEGER as a stopgap. We'll
17531 * clean things up later.
17532 */
17534 /* and skip to the next column */
17535 continue;
17536 }
17537
17538 /*
17539 * Attribute type; print it except when creating a typed
17540 * table ('OF type_name'), but in binary-upgrade mode,
17541 * print it in that case too.
17542 */
17544 {
17547 }
17548
17550 {
17557 else
17560 }
17561
17563 {
17566 else
17569
17572 }
17573
17574 /* Add collation if not default for the type */
17576 {
17577 CollInfo *coll;
17578
17580 if (coll)
17582 fmtQualifiedDumpable(coll));
17583 }
17584 }
17585
17586 /*
17587 * On the other hand, if we choose not to print a column
17588 * (likely because it is created by inheritance), but the
17589 * column has a locally-defined not-null constraint, we need
17590 * to dump the constraint as a standalone object.
17591 *
17592 * This syntax isn't SQL-conforming, but if you wanted
17593 * standard output you wouldn't be creating non-standard
17594 * objects to begin with.
17595 */
17600 {
17601 /* Format properly if not first attr */
17604 else
17607 actual_atts++;
17608
17612 else
17616
17619 }
17620 }
17621
17622 /*
17623 * Add non-inherited CHECK constraints, if any.
17624 *
17625 * For partitions, we need to include check constraints even if
17626 * they're not defined locally, because the ALTER TABLE ATTACH
17627 * PARTITION that we'll emit later expects the constraint to be
17628 * there. (No need to fix conislocal: ATTACH PARTITION does that)
17629 */
17631 {
17633
17636 continue;
17637
17640 else
17642
17646
17647 actual_atts++;
17648 }
17649
17653 {
17654 /*
17655 * No attributes? we must have a parenthesized attribute list,
17656 * even though empty, when not using the OF TYPE syntax.
17657 */
17659 }
17660
17661 /*
17662 * Emit the INHERITS clause (not for partitions), except in
17663 * binary-upgrade mode.
17664 */
17666 !dopt->binary_upgrade)
17667 {
17669 for (k = 0; k < numParents; k++)
17670 {
17672
17673 if (k > 0)
17676 }
17678 }
17679
17682
17685 }
17686
17689 {
17691
17694 {
17697 }
17699 {
17703 fout);
17704 }
17706 }
17707
17708 /* Dump generic options if any */
17711
17712 /*
17713 * For materialized views, create the AS clause just like a view. At
17714 * this point, we always mark the view as not populated.
17715 */
17717 {
17719
17722 result->data);
17724 }
17725 else
17727
17728 /* Materialized views can depend on extensions */
17731 "pg_catalog.pg_class",
17732 "MATERIALIZED VIEW",
17733 qualrelname);
17734
17735 /*
17736 * in binary upgrade mode, update the catalog with any missing values
17737 * that might be present.
17738 */
17740 {
17742 {
17744 {
17746 appendPQExpBufferStr(q,
17747 "SELECT pg_catalog.binary_upgrade_set_missing_value(");
17754 }
17755 }
17756 }
17757
17758 /*
17759 * To create binary-compatible heap files, we have to ensure the same
17760 * physical column order, including dropped columns, as in the
17761 * original. Therefore, we create dropped columns above and drop them
17762 * here, also updating their attlen/attalign values so that the
17763 * dropped column can be skipped properly. (We do not bother with
17764 * restoring the original attbyval setting.) Also, inheritance
17765 * relationships are set up by doing ALTER TABLE INHERIT rather than
17766 * using an INHERITS clause --- the latter would possibly mess up the
17767 * column order. That also means we have to take care about setting
17768 * attislocal correctly, plus fix up any inherited CHECK constraints.
17769 * Analogously, we set up typed tables using ALTER TABLE / OF here.
17770 *
17771 * We process foreign and partitioned tables here, even though they
17772 * lack heap storage, because they can participate in inheritance
17773 * relationships and we want this stuff to be consistent across the
17774 * inheritance tree. We can exclude indexes, toast tables, sequences
17775 * and matviews, even though they have storage, because we don't
17776 * support altering or dropping columns in them, nor can they be part
17777 * of inheritance trees.
17778 */
17783 {
17786
17787 /*
17788 * Drop any dropped columns. Merge the pg_attribute manipulations
17789 * into a single SQL command, so that we don't cause repeated
17790 * relcache flushes on the target table. Otherwise we risk O(N^2)
17791 * relcache bloat while dropping N columns.
17792 */
17793 resetPQExpBuffer(extra);
17796 {
17798 {
17800 {
17802 "UPDATE pg_catalog.pg_attribute\n"
17803 "SET attlen = v.dlen, "
17804 "attalign = v.dalign, "
17805 "attbyval = false\n"
17806 "FROM (VALUES ");
17808 }
17809 else
17816 /* The ALTER ... DROP COLUMN commands must come after */
17821 }
17822 }
17824 {
17826 "WHERE attrelid = ");
17829 " AND attname = v.dname;\n");
17830 /* Now we can issue the actual DROP COLUMN commands */
17832 }
17833
17834 /*
17835 * Fix up inherited columns. As above, do the pg_attribute
17836 * manipulations in a single SQL command.
17837 */
17840 {
17843 {
17845 {
17848 "SET attislocal = false\n"
17849 "WHERE attrelid = ");
17852 " AND attname IN (");
17854 }
17855 else
17858 }
17859 }
17862
17863 /*
17864 * Fix up not-null constraints that come from inheritance. As
17865 * above, do the pg_constraint manipulations in a single SQL
17866 * command. (Actually, two in special cases, if we're doing an
17867 * upgrade from < 18).
17868 */
17871 resetPQExpBuffer(extra);
17873 {
17874 /*
17875 * If a not-null constraint comes from inheritance, reset
17876 * conislocal. The inhcount is fixed by ALTER TABLE INHERIT,
17877 * below. Special hack: in versions < 18, columns with no
17878 * local definition need their constraint to be matched by
17879 * column number in conkeys instead of by constraint name,
17880 * because the latter is not available. (We distinguish the
17881 * case because the constraint name is the empty string.)
17882 */
17885 {
17887 {
17889 {
17891 "SET conislocal = false\n"
17892 "WHERE contype = 'n' AND conrelid = ");
17895 "conname IN (");
17897 }
17898 else
17901 }
17902 else
17903 {
17905 {
17907 "SET conislocal = false\n"
17908 "WHERE contype = 'n' AND conrelid = ");
17911 "conkey IN (");
17913 }
17914 else
17917 }
17918 }
17919 }
17924
17927
17928 /*
17929 * Add inherited CHECK constraints, if any.
17930 *
17931 * For partitions, they were already dumped, and conislocal
17932 * doesn't need fixing.
17933 *
17934 * As above, issue only one direct manipulation of pg_constraint.
17935 * Although it is tempting to merge the ALTER ADD CONSTRAINT
17936 * commands into one as well, refrain for now due to concern about
17937 * possible backend memory bloat if there are many such
17938 * constraints.
17939 */
17940 resetPQExpBuffer(extra);
17943 {
17945
17947 continue;
17948
17954 constr->condef);
17955 /* Update pg_constraint after all the ALTER TABLEs */
17957 {
17959 "SET conislocal = false\n"
17960 "WHERE contype = 'c' AND conrelid = ");
17965 }
17966 else
17969 }
17971 {
17974 }
17975
17977 {
17979 for (k = 0; k < numParents; k++)
17980 {
17982
17984 qualrelname,
17986 }
17987 }
17988
17990 {
17993 qualrelname,
17995 zeroIsError));
17996 }
17997 }
17998
17999 /*
18000 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
18001 * relminmxid of all vacuumable relations. (While vacuum.c processes
18002 * TOAST tables semi-independently, here we see them only as children
18003 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
18004 * child toast table is handled below.)
18005 */
18009 {
18012 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
18013 "WHERE oid = ",
18017
18019 {
18020 /*
18021 * The toast table will have the same OID at restore, so we
18022 * can safely target it by OID.
18023 */
18024 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
18026 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
18027 "WHERE oid = '%u';\n",
18028 tbinfo->toast_frozenxid,
18030 }
18031 }
18032
18033 /*
18034 * In binary_upgrade mode, restore matviews' populated status by
18035 * poking pg_class directly. This is pretty ugly, but we can't use
18036 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
18037 * matview is not populated even though this matview is; in any case,
18038 * we want to transfer the matview's heap storage, not run REFRESH.
18039 */
18041 tbinfo->relispopulated)
18042 {
18045 "SET relispopulated = 't'\n"
18046 "WHERE oid = ");
18049 }
18050
18051 /*
18052 * Dump additional per-column properties that we can't handle in the
18053 * main CREATE TABLE command.
18054 */
18056 {
18057 /* None of this applies to dropped columns */
18059 continue;
18060
18061 /*
18062 * Dump per-column statistics information. We only issue an ALTER
18063 * TABLE statement if the attstattarget entry for this column is
18064 * not the default value.
18065 */
18071
18072 /*
18073 * Dump per-column storage information. The statement is only
18074 * dumped if the storage has been changed from the type's default.
18075 */
18077 {
18079 {
18082 break;
18085 break;
18088 break;
18091 break;
18092 default:
18094 }
18095
18096 /*
18097 * Only dump the statement if it's a storage type we recognize
18098 */
18103 storage);
18104 }
18105
18106 /*
18107 * Dump per-column compression, if it's been set.
18108 */
18110 {
18112
18114 {
18115 case 'p':
18117 break;
18118 case 'l':
18120 break;
18121 default:
18123 break;
18124 }
18125
18130 cmname);
18131 }
18132
18133 /*
18134 * Dump per-column attributes.
18135 */
18141
18142 /*
18143 * Dump per-column fdw options.
18144 */
18147 appendPQExpBuffer(q,
18148 "ALTER FOREIGN TABLE ONLY %s ALTER COLUMN %s OPTIONS (\n"
18149 " %s\n"
18150 ");\n",
18151 qualrelname,
18154 } /* end loop over columns */
18155
18159 }
18160
18161 /*
18162 * dump properties we only have ALTER TABLE syntax for
18163 */
18168 {
18170 {
18171 /* nothing to do, will be set when the index is dumped */
18172 }
18174 {
18176 qualrelname);
18177 }
18179 {
18181 qualrelname);
18182 }
18183 }
18184
18187 qualrelname);
18188
18190
18194 tbinfo->dobj.namespace->dobj.name);
18195
18197 {
18200
18201 /*
18202 * _selectTablespace() relies on tablespace-enabled objects in the
18203 * default tablespace to have a tablespace of "" (empty string) versus
18204 * non-tablespace-enabled objects to have a tablespace of NULL.
18205 * getTables() sets tbinfo->reltablespace to "" for the default
18206 * tablespace (not NULL).
18207 */
18210
18213 tableam = tbinfo->amname;
18214
18217 .namespace = tbinfo->dobj.namespace->dobj.name,
18218 .tablespace = tablespace,
18219 .tableam = tableam,
18220 .relkind = tbinfo->relkind,
18221 .owner = tbinfo->rolname,
18222 .description = reltypename,
18223 .section = tbinfo->postponed_def ?
18225 .createStmt = q->data,
18227 }
18228
18229 /* Dump Table Comments */
18232
18233 /* Dump Table Security Labels */
18236
18237 /*
18238 * Dump comments for not-null constraints that aren't to be dumped
18239 * separately (those are processed by collectComments/dumpComment).
18240 */
18243 {
18246
18248 {
18251 {
18253 {
18255 tag = createPQExpBuffer();
18256 }
18257 else
18258 {
18260 resetPQExpBuffer(tag);
18261 }
18262
18267
18270
18273 .namespace = tbinfo->dobj.namespace->dobj.name,
18274 .owner = tbinfo->rolname,
18275 .description = "COMMENT",
18276 .section = SECTION_NONE,
18277 .createStmt = comment->data,
18278 .deps = &(tbinfo->dobj.dumpId),
18279 .nDeps = 1));
18280 }
18281 }
18282
18284 destroyPQExpBuffer(tag);
18285 }
18286
18287 /* Dump comments on inlined table constraints */
18289 {
18291
18293 continue;
18294
18297 }
18298
18299 destroyPQExpBuffer(q);
18301 destroyPQExpBuffer(extra);
18304}
18305
18306/*
18307 * dumpTableAttach
18308 * write to fout the commands to attach a child partition
18309 *
18310 * Child partitions are always made by creating them separately
18311 * and then using ATTACH PARTITION, rather than using
18312 * CREATE TABLE ... PARTITION OF. This is important for preserving
18313 * any possible discrepancy in column layout, to allow assigning the
18314 * correct tablespace if different, and so that it's possible to restore
18315 * a partition without restoring its parent. (You'll get an error from
18316 * the ATTACH PARTITION command, but that can be ignored, or skipped
18317 * using "pg_restore -L" if you prefer.) The last point motivates
18318 * treating ATTACH PARTITION as a completely separate ArchiveEntry
18319 * rather than emitting it within the child partition's ArchiveEntry.
18320 */
18321static void
18323{
18325 PQExpBuffer q;
18326 PGresult *res;
18327 char *partbound;
18328
18329 /* Do nothing if not dumping schema */
18331 return;
18332
18333 q = createPQExpBuffer();
18334
18336 {
18337 /* Set up query for partbound details */
18338 appendPQExpBufferStr(q,
18339 "PREPARE dumpTableAttach(pg_catalog.oid) AS\n");
18340
18341 appendPQExpBufferStr(q,
18342 "SELECT pg_get_expr(c.relpartbound, c.oid) "
18343 "FROM pg_class c "
18344 "WHERE c.oid = $1");
18345
18347
18349 }
18350
18351 printfPQExpBuffer(q,
18352 "EXECUTE dumpTableAttach('%u')",
18353 attachinfo->partitionTbl->dobj.catId.oid);
18354
18356 partbound = PQgetvalue(res, 0, 0);
18357
18358 /* Perform ALTER TABLE on the parent */
18359 printfPQExpBuffer(q,
18360 "ALTER TABLE ONLY %s ",
18362 appendPQExpBuffer(q,
18363 "ATTACH PARTITION %s %s;\n",
18365 partbound);
18366
18367 /*
18368 * There is no point in creating a drop query as the drop is done by table
18369 * drop. (If you think to change this, see also _printTocEntry().)
18370 * Although this object doesn't really have ownership as such, set the
18371 * owner field anyway to ensure that the command is run by the correct
18372 * role at restore time.
18373 */
18376 .namespace = attachinfo->dobj.namespace->dobj.name,
18377 .owner = attachinfo->partitionTbl->rolname,
18378 .description = "TABLE ATTACH",
18379 .section = SECTION_PRE_DATA,
18380 .createStmt = q->data));
18381
18382 PQclear(res);
18383 destroyPQExpBuffer(q);
18384}
18385
18386/*
18387 * dumpAttrDef --- dump an attribute's default-value declaration
18388 */
18389static void
18391{
18395 PQExpBuffer q;
18398 char *tag;
18400
18401 /* Do nothing if not dumping schema */
18403 return;
18404
18405 /* Skip if not "separate"; it was dumped in the table's definition */
18407 return;
18408
18409 q = createPQExpBuffer();
18411
18413
18415
18416 appendPQExpBuffer(q,
18417 "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
18419 adinfo->adef_expr);
18420
18424
18426
18429 ARCHIVE_OPTS(.tag = tag,
18431 .owner = tbinfo->rolname,
18432 .description = "DEFAULT",
18433 .section = SECTION_PRE_DATA,
18434 .createStmt = q->data,
18435 .dropStmt = delq->data));
18436
18437 free(tag);
18438 destroyPQExpBuffer(q);
18441}
18442
18443/*
18444 * getAttrName: extract the correct name for an attribute
18445 *
18446 * The array tblInfo->attnames[] only provides names of user attributes;
18447 * if a system attribute number is supplied, we have to fake it.
18448 * We also do a little bit of bounds checking for safety's sake.
18449 */
18450static const char *
18452{
18455 switch (attrnum)
18456 {
18458 return "ctid";
18460 return "xmin";
18462 return "cmin";
18464 return "xmax";
18466 return "cmax";
18468 return "tableoid";
18469 }
18471 attrnum, tblInfo->dobj.name);
18473}
18474
18475/*
18476 * dumpIndex
18477 * write out to fout a user-defined index
18478 */
18479static void
18481{
18485 PQExpBuffer q;
18489
18490 /* Do nothing if not dumping schema */
18492 return;
18493
18494 q = createPQExpBuffer();
18496
18499
18500 /*
18501 * If there's an associated constraint, don't dump the index per se, but
18502 * do dump any comment for it. (This is safe because dependency ordering
18503 * will have ensured the constraint is emitted first.) Note that the
18504 * emitted comment has to be shown as depending on the constraint, not the
18505 * index, in such cases.
18506 */
18508 {
18515
18518 indxinfo->dobj.catId.oid);
18519
18520 /* Plain secondary index */
18522
18523 /*
18524 * Append ALTER TABLE commands as needed to set properties that we
18525 * only have ALTER TABLE syntax for. Keep this in sync with the
18526 * similar code in dumpConstraint!
18527 */
18528
18529 /* If the index is clustered, we need to record that. */
18531 {
18534 /* index name is not qualified in this syntax */
18536 qindxname);
18537 }
18538
18539 /*
18540 * If the index has any statistics on some of its columns, generate
18541 * the associated ALTER INDEX queries.
18542 */
18544 {
18546
18553
18555 {
18557
18558 /*
18559 * Note that this is a column number, so no quotes should be
18560 * used.
18561 */
18566 }
18567 }
18568
18569 /* Indexes can depend on extensions */
18571 "pg_catalog.pg_class",
18573
18574 /* If the index defines identity, we need to record that. */
18576 {
18579 /* index name is not qualified in this syntax */
18581 qindxname);
18582 }
18583
18584 /*
18585 * If this index is a member of a partitioned index, the backend will
18586 * not allow us to drop it separately, so don't try. It will go away
18587 * automatically when we drop either the index's table or the
18588 * partitioned index. (If, in a selective restore with --clean, we
18589 * drop neither of those, then this index will not be dropped either.
18590 * But that's fine, and even if you think it's not, the backend won't
18591 * let us do differently.)
18592 */
18595
18599 .namespace = tbinfo->dobj.namespace->dobj.name,
18600 .tablespace = indxinfo->tablespace,
18601 .owner = tbinfo->rolname,
18602 .description = "INDEX",
18603 .section = SECTION_POST_DATA,
18604 .createStmt = q->data,
18605 .dropStmt = delq->data));
18606
18609 }
18610
18611 /* Dump Index Comments */
18614 tbinfo->dobj.namespace->dobj.name,
18615 tbinfo->rolname,
18616 indxinfo->dobj.catId, 0,
18618 indxinfo->dobj.dumpId);
18619
18620 destroyPQExpBuffer(q);
18624}
18625
18626/*
18627 * dumpIndexAttach
18628 * write out to fout a partitioned-index attachment clause
18629 */
18630static void
18632{
18633 /* Do nothing if not dumping schema */
18635 return;
18636
18638 {
18640
18645
18646 /*
18647 * There is no need for a dropStmt since the drop is done implicitly
18648 * when we drop either the index's table or the partitioned index.
18649 * Moreover, since there's no ALTER INDEX DETACH PARTITION command,
18650 * there's no way to do it anyway. (If you think to change this,
18651 * consider also what to do with --if-exists.)
18652 *
18653 * Although this object doesn't really have ownership as such, set the
18654 * owner field anyway to ensure that the command is run by the correct
18655 * role at restore time.
18656 */
18659 .namespace = attachinfo->dobj.namespace->dobj.name,
18660 .owner = attachinfo->parentIdx->indextable->rolname,
18661 .description = "INDEX ATTACH",
18662 .section = SECTION_POST_DATA,
18663 .createStmt = q->data));
18664
18665 destroyPQExpBuffer(q);
18666 }
18667}
18668
18669/*
18670 * dumpStatisticsExt
18671 * write out to fout an extended statistics object
18672 */
18673static void
18675{
18677 PQExpBuffer q;
18679 PQExpBuffer query;
18681 PGresult *res;
18683
18684 /* Do nothing if not dumping schema */
18686 return;
18687
18688 q = createPQExpBuffer();
18690 query = createPQExpBuffer();
18691
18693
18695 "pg_catalog.pg_get_statisticsobjdef('%u'::pg_catalog.oid)",
18696 statsextinfo->dobj.catId.oid);
18697
18699
18701
18702 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
18704
18705 /*
18706 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
18707 * for this statistics object is not the default value.
18708 */
18710 {
18714 statsextinfo->stattarget);
18715 }
18716
18719
18722 statsextinfo->dobj.dumpId,
18724 .namespace = statsextinfo->dobj.namespace->dobj.name,
18725 .owner = statsextinfo->rolname,
18726 .description = "STATISTICS",
18727 .section = SECTION_POST_DATA,
18728 .createStmt = q->data,
18729 .dropStmt = delq->data));
18730
18731 /* Dump Statistics Comments */
18734 statsextinfo->dobj.namespace->dobj.name,
18735 statsextinfo->rolname,
18736 statsextinfo->dobj.catId, 0,
18737 statsextinfo->dobj.dumpId);
18738
18739 PQclear(res);
18740 destroyPQExpBuffer(q);
18742 destroyPQExpBuffer(query);
18744}
18745
18746/*
18747 * dumpStatisticsExtStats
18748 * write out to fout the stats for an extended statistics object
18749 */
18750static void
18752{
18754 PQExpBuffer query;
18755 PGresult *res;
18756 int nstats;
18757
18758 /* Do nothing if not dumping statistics */
18760 return;
18761
18763 {
18765
18766 /*---------
18767 * Set up query for details about extended statistics objects.
18768 *
18769 * The query depends on the backend version:
18770 * - In v19 and newer versions, query directly the pg_stats_ext*
18771 * catalogs.
18772 * - In v18 and older versions, ndistinct and dependencies have a
18773 * different format that needs translation.
18774 * - In v14 and older versions, inherited does not exist.
18775 * - In v11 and older versions, there is no pg_stats_ext, hence
18776 * the logic joins pg_statistic_ext and pg_namespace.
18777 *---------
18778 */
18779
18781 "PREPARE getExtStatsStats(pg_catalog.name, pg_catalog.name) AS\n"
18782 "SELECT ");
18783
18784 /*
18785 * Versions 15 and newer have inherited stats.
18786 *
18787 * Create this column in all versions because we need to order by it
18788 * later.
18789 */
18792 else
18794
18795 /*--------
18796 * The ndistinct and dependencies formats changed in v19, so
18797 * everything before that needs to be translated.
18798 *
18799 * The ndistinct translation converts this kind of data:
18800 * {"3, 4": 11, "3, 6": 11, "4, 6": 11, "3, 4, 6": 11}
18801 *
18802 * to this:
18803 * [ {"attributes": [3,4], "ndistinct": 11},
18804 * {"attributes": [3,6], "ndistinct": 11},
18805 * {"attributes": [4,6], "ndistinct": 11},
18806 * {"attributes": [3,4,6], "ndistinct": 11} ]
18807 *
18808 * The dependencies translation converts this kind of data:
18809 * {"3 => 4": 1.000000, "3 => 6": 1.000000,
18810 * "4 => 6": 1.000000, "3, 4 => 6": 1.000000,
18811 * "3, 6 => 4": 1.000000}
18812 *
18813 * to this:
18814 * [ {"attributes": [3], "dependency": 4, "degree": 1.000000},
18815 * {"attributes": [3], "dependency": 6, "degree": 1.000000},
18816 * {"attributes": [4], "dependency": 6, "degree": 1.000000},
18817 * {"attributes": [3,4], "dependency": 6, "degree": 1.000000},
18818 * {"attributes": [3,6], "dependency": 4, "degree": 1.000000} ]
18819 *--------
18820 */
18823 else
18825 "( "
18826 "SELECT json_agg( "
18827 " json_build_object( "
18829 " string_to_array(kv.key, ', ')::integer[], "
18831 " kv.value::bigint )) "
18832 "FROM json_each_text(e.n_distinct::text::json) AS kv"
18833 ") AS n_distinct, "
18834 "( "
18835 "SELECT json_agg( "
18836 " json_build_object( "
18838 " string_to_array( "
18839 " split_part(kv.key, ' => ', 1), "
18840 " ', ')::integer[], "
18842 " split_part(kv.key, ' => ', 2)::integer, "
18844 " kv.value::double precision )) "
18845 "FROM json_each_text(e.dependencies::text::json) AS kv "
18846 ") AS dependencies, ");
18847
18848 /* MCV was introduced v13 */
18851 "e.most_common_vals, e.most_common_freqs, "
18852 "e.most_common_base_freqs, ");
18853 else
18855 "NULL AS most_common_vals, NULL AS most_common_freqs, "
18856 "NULL AS most_common_base_freqs, ");
18857
18858 /* Expressions were introduced in v14 */
18860 {
18861 /*
18862 * There is no ordering column in pg_stats_ext_exprs. However, we
18863 * can rely on the unnesting of pg_statistic_ext_data.stxdexpr to
18864 * maintain the desired order of expression elements.
18865 */
18867 "( "
18868 "SELECT jsonb_pretty(jsonb_agg("
18869 "nullif(j.obj, '{}'::jsonb))) "
18870 "FROM pg_stats_ext_exprs AS ee "
18871 "CROSS JOIN LATERAL jsonb_strip_nulls("
18872 " jsonb_build_object( "
18873 " 'null_frac', ee.null_frac::text, "
18874 " 'avg_width', ee.avg_width::text, "
18875 " 'n_distinct', ee.n_distinct::text, "
18876 " 'most_common_vals', ee.most_common_vals::text, "
18877 " 'most_common_freqs', ee.most_common_freqs::text, "
18878 " 'histogram_bounds', ee.histogram_bounds::text, "
18879 " 'correlation', ee.correlation::text, "
18880 " 'most_common_elems', ee.most_common_elems::text, "
18881 " 'most_common_elem_freqs', ee.most_common_elem_freqs::text, "
18882 " 'elem_count_histogram', ee.elem_count_histogram::text");
18883
18884 /* These three have been added to pg_stats_ext_exprs in v19. */
18887 ", "
18888 " 'range_length_histogram', ee.range_length_histogram::text, "
18889 " 'range_empty_frac', ee.range_empty_frac::text, "
18890 " 'range_bounds_histogram', ee.range_bounds_histogram::text");
18891
18893 " )) AS j(obj)"
18894 "WHERE ee.statistics_schemaname = $1 "
18895 "AND ee.statistics_name = $2 ");
18896 /* Inherited expressions introduced in v15 */
18899
18901 }
18902 else
18904
18905 /* pg_stats_ext introduced in v12 */
18908 "FROM pg_catalog.pg_stats_ext AS e "
18909 "WHERE e.statistics_schemaname = $1 "
18910 "AND e.statistics_name = $2 ");
18911 else
18913 "FROM ( "
18914 "SELECT s.stxndistinct AS n_distinct, "
18915 " s.stxdependencies AS dependencies "
18916 "FROM pg_catalog.pg_statistic_ext AS s "
18917 "JOIN pg_catalog.pg_namespace AS n "
18918 "ON n.oid = s.stxnamespace "
18919 "WHERE n.nspname = $1 "
18920 "AND s.stxname = $2 "
18921 ") AS e ");
18922
18923 /* we always have an inherited column, but it may be a constant */
18925
18927
18929
18931 }
18932
18933 query = createPQExpBuffer();
18934
18940
18942
18943 destroyPQExpBuffer(query);
18944
18945 nstats = PQntuples(res);
18946
18947 if (nstats > 0)
18948 {
18950
18958
18960 {
18962
18965
18966 appendPQExpBufferStr(out,
18967 "SELECT * FROM pg_catalog.pg_restore_extended_stats(\n");
18970
18971 /* Relation information */
18976
18977 /* Extended statistics information */
18984
18988
18992
18996
19000
19004
19008
19010 }
19011
19014 .namespace = statsextinfo->dobj.namespace->dobj.name,
19015 .owner = statsextinfo->rolname,
19016 .description = "EXTENDED STATISTICS DATA",
19017 .section = SECTION_POST_DATA,
19018 .createStmt = out->data,
19019 .deps = &statsextinfo->dobj.dumpId,
19020 .nDeps = 1));
19021 destroyPQExpBuffer(out);
19022 }
19023 PQclear(res);
19024}
19025
19026/*
19027 * dumpConstraint
19028 * write out to fout a user-defined constraint
19029 */
19030static void
19032{
19035 PQExpBuffer q;
19039
19040 /* Do nothing if not dumping schema */
19042 return;
19043
19044 q = createPQExpBuffer();
19046
19049
19053 {
19054 /* Index-related constraint */
19056 int k;
19057
19059
19062 coninfo->dobj.name);
19063
19066 indxinfo->dobj.catId.oid);
19067
19072
19074 {
19075 /* pg_get_constraintdef should have provided everything */
19077 }
19078 else
19079 {
19080 appendPQExpBufferStr(q,
19082
19083 /*
19084 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
19085 * indexes. Being able to create this was fixed, but we need to
19086 * make the index distinct in order to be able to restore the
19087 * dump.
19088 */
19093 {
19096
19098 break;
19100
19102 (k == 0) ? "" : ", ",
19104 }
19107
19110
19112 {
19115
19117 break;
19119
19123 }
19124
19126
19128 {
19132 }
19133
19135 {
19139 }
19140
19142 }
19143
19144 /*
19145 * Append ALTER TABLE commands as needed to set properties that we
19146 * only have ALTER TABLE syntax for. Keep this in sync with the
19147 * similar code in dumpIndex!
19148 */
19149
19150 /* If the index is clustered, we need to record that. */
19152 {
19155 /* index name is not qualified in this syntax */
19158 }
19159
19160 /* If the index defines identity, we need to record that. */
19162 {
19165 /* index name is not qualified in this syntax */
19168 }
19169
19170 /* Indexes can depend on extensions */
19172 "pg_catalog.pg_class", "INDEX",
19174
19179
19181
19184 ARCHIVE_OPTS(.tag = tag,
19186 .tablespace = indxinfo->tablespace,
19187 .owner = tbinfo->rolname,
19188 .description = "CONSTRAINT",
19189 .section = SECTION_POST_DATA,
19190 .createStmt = q->data,
19191 .dropStmt = delq->data));
19192 }
19194 {
19196
19197 /*
19198 * Foreign keys on partitioned tables are always declared as
19199 * inheriting to partitions; for all other cases, emit them as
19200 * applying ONLY directly to the named table, because that's how they
19201 * work for regular inherited tables.
19202 */
19204
19205 /*
19206 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
19207 * current table data is not processed
19208 */
19213 coninfo->condef);
19214
19219
19221
19224 ARCHIVE_OPTS(.tag = tag,
19226 .owner = tbinfo->rolname,
19227 .description = "FK CONSTRAINT",
19228 .section = SECTION_POST_DATA,
19229 .createStmt = q->data,
19230 .dropStmt = delq->data));
19231 }
19233 {
19234 /* CHECK or invalid not-null constraint on a table */
19235
19236 /* Ignore if not to be dumped separately, or if it was inherited */
19238 {
19239 const char *keyword;
19240
19242 keyword = "CHECK CONSTRAINT";
19243 else
19244 keyword = "CONSTRAINT";
19245
19246 /* not ONLY since we want it to propagate to children */
19251 coninfo->condef);
19252
19257
19259
19262 ARCHIVE_OPTS(.tag = tag,
19264 .owner = tbinfo->rolname,
19265 .description = keyword,
19266 .section = SECTION_POST_DATA,
19267 .createStmt = q->data,
19268 .dropStmt = delq->data));
19269 }
19270 }
19272 {
19273 /* CHECK, NOT NULL constraint on a domain */
19275
19277
19278 /* Ignore if not to be dumped separately */
19280 {
19281 const char *keyword;
19282
19284 keyword = "CHECK CONSTRAINT";
19285 else
19286 keyword = "CONSTRAINT";
19287
19292 coninfo->condef);
19293
19298
19300
19303 ARCHIVE_OPTS(.tag = tag,
19305 .owner = tyinfo->rolname,
19306 .description = keyword,
19307 .section = SECTION_POST_DATA,
19308 .createStmt = q->data,
19309 .dropStmt = delq->data));
19310
19312 {
19315
19318
19320 tyinfo->dobj.namespace->dobj.name,
19321 tyinfo->rolname,
19325 }
19326 }
19327 }
19328 else
19329 {
19331 coninfo->contype);
19332 }
19333
19334 /* Dump Constraint Comments --- only works for table constraints */
19338
19339 free(tag);
19340 destroyPQExpBuffer(q);
19342}
19343
19344/*
19345 * dumpTableConstraintComment --- dump a constraint's comment if any
19346 *
19347 * This is split out because we need the function in two different places
19348 * depending on whether the constraint is dumped as part of CREATE TABLE
19349 * or as a separate ALTER command.
19350 */
19351static void
19353{
19357
19359
19362
19365 tbinfo->dobj.namespace->dobj.name,
19366 tbinfo->rolname,
19367 coninfo->dobj.catId, 0,
19369
19372}
19373
19376{
19378 {
19381 }
19382
19385}
19386
19387/*
19388 * bsearch() comparator for SequenceItem
19389 */
19390static int
19392{
19395
19397}
19398
19399/*
19400 * collectSequences
19401 *
19402 * Construct a table of sequence information. This table is sorted by OID for
19403 * speed in lookup.
19404 */
19405static void
19407{
19408 PGresult *res;
19409 const char *query;
19410
19411 /*
19412 * Before Postgres 10, sequence metadata is in the sequence itself. With
19413 * some extra effort, we might be able to use the sorted table for those
19414 * versions, but for now it seems unlikely to be worth it.
19415 *
19416 * Since version 18, we can gather the sequence data in this query with
19417 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19418 */
19420 return;
19423 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19424 "seqstart, seqincrement, "
19425 "seqmax, seqmin, "
19426 "seqcache, seqcycle, "
19427 "NULL, 'f' "
19428 "FROM pg_catalog.pg_sequence "
19429 "ORDER BY seqrelid";
19430 else
19431 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19432 "seqstart, seqincrement, "
19433 "seqmax, seqmin, "
19434 "seqcache, seqcycle, "
19435 "last_value, is_called "
19436 "FROM pg_catalog.pg_sequence, "
19437 "pg_get_sequence_data(seqrelid) "
19438 "ORDER BY seqrelid;";
19439
19441
19444
19446 {
19458 }
19459
19460 PQclear(res);
19461}
19462
19463/*
19464 * dumpSequence
19465 * write the declaration (not data) of one user-defined sequence
19466 */
19467static void
19469{
19474 default_maxv;
19479
19481
19482 /*
19483 * For versions >= 10, the sequence information is gathered in a sorted
19484 * table before any calls to dumpSequence(). See collectSequences() for
19485 * more information.
19486 */
19488 {
19490
19492
19496 }
19497 else
19498 {
19499 PGresult *res;
19500
19501 /*
19502 * Before PostgreSQL 10, sequence metadata is in the sequence itself.
19503 *
19504 * Note: it might seem that 'bigint' potentially needs to be
19505 * schema-qualified, but actually that's a keyword.
19506 */
19507 appendPQExpBuffer(query,
19508 "SELECT 'bigint' AS sequence_type, "
19509 "start_value, increment_by, max_value, min_value, "
19510 "cache_value, is_cycled FROM %s",
19512
19514
19517 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19518 PQntuples(res)),
19520
19529
19530 PQclear(res);
19531 }
19532
19533 /* Calculate default limits for a sequence of this type */
19536 {
19539 }
19541 {
19544 }
19546 {
19549 }
19550 else
19551 {
19554 }
19555
19556 /*
19557 * Identity sequences are not to be dropped separately.
19558 */
19560 {
19563 }
19564
19565 resetPQExpBuffer(query);
19566
19568 {
19570 tbinfo->dobj.catId.oid);
19571
19572 /*
19573 * In older PG versions a sequence will have a pg_type entry, but v14
19574 * and up don't use that, so don't attempt to preserve the type OID.
19575 */
19576 }
19577
19579 {
19581
19582 appendPQExpBuffer(query,
19583 "ALTER TABLE %s ",
19584 fmtQualifiedDumpable(owning_tab));
19585 appendPQExpBuffer(query,
19586 "ALTER COLUMN %s ADD GENERATED ",
19594
19595 /*
19596 * Emit persistence option only if it's different from the owning
19597 * table's. This avoids using this new syntax unnecessarily.
19598 */
19602 "UNLOGGED" : "LOGGED");
19603 }
19604 else
19605 {
19606 appendPQExpBuffer(query,
19607 "CREATE %sSEQUENCE %s\n",
19609 "UNLOGGED " : "",
19611
19614 }
19615
19617
19619
19622 else
19624
19627 else
19629
19630 appendPQExpBuffer(query,
19633
19636 else
19638
19639 /* binary_upgrade: no need to clear TOAST table oid */
19640
19644 tbinfo->dobj.namespace->dobj.name);
19645
19649 .namespace = tbinfo->dobj.namespace->dobj.name,
19650 .owner = tbinfo->rolname,
19651 .description = "SEQUENCE",
19652 .section = SECTION_PRE_DATA,
19653 .createStmt = query->data,
19654 .dropStmt = delqry->data));
19655
19656 /*
19657 * If the sequence is owned by a table column, emit the ALTER for it as a
19658 * separate TOC entry immediately following the sequence's own entry. It's
19659 * OK to do this rather than using full sorting logic, because the
19660 * dependency that tells us it's owned will have forced the table to be
19661 * created first. We can't just include the ALTER in the TOC entry
19662 * because it will fail if we haven't reassigned the sequence owner to
19663 * match the table's owner.
19664 *
19665 * We need not schema-qualify the table reference because both sequence
19666 * and table must be in the same schema.
19667 */
19669 {
19671
19675
19677 {
19678 resetPQExpBuffer(query);
19682 fmtQualifiedDumpable(owning_tab));
19685
19689 .namespace = tbinfo->dobj.namespace->dobj.name,
19690 .owner = tbinfo->rolname,
19691 .description = "SEQUENCE OWNED BY",
19692 .section = SECTION_PRE_DATA,
19693 .createStmt = query->data,
19694 .deps = &(tbinfo->dobj.dumpId),
19695 .nDeps = 1));
19696 }
19697 }
19698
19699 /* Dump Sequence Comments and Security Labels */
19704
19709
19712 destroyPQExpBuffer(query);
19715}
19716
19717/*
19718 * dumpSequenceData
19719 * write the data of one user-defined sequence
19720 */
19721static void
19723{
19725 int64 last;
19727 PQExpBuffer query;
19728
19729 /* needn't bother if not dumping sequence data */
19731 return;
19732
19733 query = createPQExpBuffer();
19734
19735 /*
19736 * For versions >= 18, the sequence information is gathered in the sorted
19737 * array before any calls to dumpSequenceData(). See collectSequences()
19738 * for more information.
19739 *
19740 * For older versions, we have to query the sequence relations
19741 * individually.
19742 */
19744 {
19745 PGresult *res;
19746
19747 appendPQExpBuffer(query,
19748 "SELECT last_value, is_called FROM %s",
19750
19752
19755 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19756 PQntuples(res)),
19758
19761
19762 PQclear(res);
19763 }
19764 else
19765 {
19767 SequenceItem *entry;
19768
19771
19775
19778 "SELECT privilege on the sequence or the sequence may "
19779 "have been concurrently dropped",
19780 tbinfo->dobj.name);
19781
19782 last = entry->last_value;
19784 }
19785
19786 resetPQExpBuffer(query);
19791
19795 .namespace = tbinfo->dobj.namespace->dobj.name,
19796 .owner = tbinfo->rolname,
19797 .description = "SEQUENCE SET",
19798 .section = SECTION_DATA,
19799 .createStmt = query->data,
19800 .deps = &(tbinfo->dobj.dumpId),
19801 .nDeps = 1));
19802
19803 destroyPQExpBuffer(query);
19804}
19805
19806/*
19807 * dumpTrigger
19808 * write the declaration of one user-defined table trigger
19809 */
19810static void
19812{
19815 PQExpBuffer query;
19820 char *tag;
19821
19822 /* Do nothing if not dumping schema */
19824 return;
19825
19826 query = createPQExpBuffer();
19830
19832
19835
19838
19839 /* Triggers can depend on extensions */
19841 "pg_catalog.pg_trigger", "TRIGGER",
19842 trigidentity->data);
19843
19845 {
19847
19848 /*
19849 * Partition triggers only appear here because their 'tgenabled' flag
19850 * differs from its parent's. The trigger is created already, so
19851 * remove the CREATE and replace it with an ALTER. (Clear out the
19852 * DROP query too, so that pg_dump --create does not cause errors.)
19853 */
19854 resetPQExpBuffer(query);
19860 {
19861 case 'f':
19862 case 'D':
19864 break;
19865 case 't':
19866 case 'O':
19868 break;
19869 case 'R':
19871 break;
19872 case 'A':
19874 break;
19875 }
19878 }
19880 {
19885 {
19886 case 'D':
19887 case 'f':
19889 break;
19890 case 'A':
19892 break;
19893 case 'R':
19895 break;
19896 default:
19898 break;
19899 }
19902 }
19903
19906
19908
19911 ARCHIVE_OPTS(.tag = tag,
19913 .owner = tbinfo->rolname,
19914 .description = "TRIGGER",
19915 .section = SECTION_POST_DATA,
19916 .createStmt = query->data,
19917 .dropStmt = delqry->data));
19918
19923
19924 free(tag);
19925 destroyPQExpBuffer(query);
19930}
19931
19932/*
19933 * dumpEventTrigger
19934 * write the declaration of one user-defined event trigger
19935 */
19936static void
19938{
19940 PQExpBuffer query;
19943
19944 /* Do nothing if not dumping schema */
19946 return;
19947
19948 query = createPQExpBuffer();
19950
19952
19957
19959 {
19963 }
19964
19968
19970 {
19972 qevtname);
19974 {
19975 case 'D':
19977 break;
19978 case 'A':
19980 break;
19981 case 'R':
19983 break;
19984 default:
19986 break;
19987 }
19989 }
19990
19992 qevtname);
19993
19997
20001 .owner = evtinfo->evtowner,
20002 .description = "EVENT TRIGGER",
20003 .section = SECTION_POST_DATA,
20004 .createStmt = query->data,
20005 .dropStmt = delqry->data));
20006
20011
20016
20017 destroyPQExpBuffer(query);
20020}
20021
20022/*
20023 * dumpRule
20024 * Dump a rule
20025 */
20026static void
20028{
20032 PQExpBuffer query;
20033 PQExpBuffer cmd;
20037 PGresult *res;
20038 char *tag;
20039
20040 /* Do nothing if not dumping schema */
20042 return;
20043
20044 /*
20045 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
20046 * we do not want to dump it as a separate object.
20047 */
20049 return;
20050
20051 /*
20052 * If it's an ON SELECT rule, we want to print it as a view definition,
20053 * instead of a rule.
20054 */
20056
20057 query = createPQExpBuffer();
20058 cmd = createPQExpBuffer();
20061
20063
20065 {
20067
20068 /*
20069 * We need OR REPLACE here because we'll be replacing a dummy view.
20070 * Otherwise this should look largely like the regular view dump code.
20071 */
20075 {
20079 }
20085 tbinfo->checkoption);
20087 }
20088 else
20089 {
20090 /* In the rule case, just print pg_get_ruledef's result verbatim */
20091 appendPQExpBuffer(query,
20092 "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid)",
20094
20096
20100
20102
20103 PQclear(res);
20104 }
20105
20106 /*
20107 * Add the command to alter the rules replication firing semantics if it
20108 * differs from the default.
20109 */
20111 {
20114 {
20115 case 'A':
20118 break;
20119 case 'R':
20122 break;
20123 case 'D':
20126 break;
20127 }
20128 }
20129
20131 {
20132 /*
20133 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
20134 * REPLACE VIEW to replace the rule with something with minimal
20135 * dependencies.
20136 */
20138
20144 }
20145 else
20146 {
20151 }
20152
20155
20157
20160 ARCHIVE_OPTS(.tag = tag,
20162 .owner = tbinfo->rolname,
20163 .description = "RULE",
20164 .section = SECTION_POST_DATA,
20165 .createStmt = cmd->data,
20166 .dropStmt = delcmd->data));
20167
20168 /* Dump rule comments */
20171 tbinfo->dobj.namespace->dobj.name,
20172 tbinfo->rolname,
20174
20175 free(tag);
20176 destroyPQExpBuffer(query);
20177 destroyPQExpBuffer(cmd);
20181}
20182
20183/*
20184 * getExtensionMembership --- obtain extension membership data
20185 *
20186 * We need to identify objects that are extension members as soon as they're
20187 * loaded, so that we can correctly determine whether they need to be dumped.
20188 * Generally speaking, extension member objects will get marked as *not* to
20189 * be dumped, as they will be recreated by the single CREATE EXTENSION
20190 * command. However, in binary upgrade mode we still need to dump the members
20191 * individually.
20192 */
20193void
20196{
20197 PQExpBuffer query;
20198 PGresult *res;
20199 int ntups,
20200 i;
20202 i_objid,
20203 i_refobjid;
20204 ExtensionInfo *ext;
20205
20206 /* Nothing to do if no extensions */
20208 return;
20209
20210 query = createPQExpBuffer();
20211
20212 /* refclassid constraint is redundant but may speed the search */
20214 "classid, objid, refobjid "
20215 "FROM pg_depend "
20216 "WHERE refclassid = 'pg_extension'::regclass "
20217 "AND deptype = 'e' "
20218 "ORDER BY 3");
20219
20221
20222 ntups = PQntuples(res);
20223
20227
20228 /*
20229 * Since we ordered the SELECT by referenced ID, we can expect that
20230 * multiple entries for the same extension will appear together; this
20231 * saves on searches.
20232 */
20233 ext = NULL;
20234
20236 {
20237 CatalogId objId;
20239
20243
20247
20249 {
20250 /* shouldn't happen */
20252 continue;
20253 }
20254
20255 recordExtensionMembership(objId, ext);
20256 }
20257
20258 PQclear(res);
20259
20260 destroyPQExpBuffer(query);
20261}
20262
20263/*
20264 * processExtensionTables --- deal with extension configuration tables
20265 *
20266 * There are two parts to this process:
20267 *
20268 * 1. Identify and create dump records for extension configuration tables.
20269 *
20270 * Extensions can mark tables as "configuration", which means that the user
20271 * is able and expected to modify those tables after the extension has been
20272 * loaded. For these tables, we dump out only the data- the structure is
20273 * expected to be handled at CREATE EXTENSION time, including any indexes or
20274 * foreign keys, which brings us to-
20275 *
20276 * 2. Record FK dependencies between configuration tables.
20277 *
20278 * Due to the FKs being created at CREATE EXTENSION time and therefore before
20279 * the data is loaded, we have to work out what the best order for reloading
20280 * the data is, to avoid FK violations when the tables are restored. This is
20281 * not perfect- we can't handle circular dependencies and if any exist they
20282 * will cause an invalid dump to be produced (though at least all of the data
20283 * is included for a user to manually restore). This is currently documented
20284 * but perhaps we can provide a better solution in the future.
20285 */
20286void
20289{
20291 PQExpBuffer query;
20292 PGresult *res;
20293 int ntups,
20294 i;
20296 i_confrelid;
20297
20298 /* Nothing to do if no extensions */
20300 return;
20301
20302 /*
20303 * Identify extension configuration tables and create TableDataInfo
20304 * objects for them, ensuring their data will be dumped even though the
20305 * tables themselves won't be.
20306 *
20307 * Note that we create TableDataInfo objects even in schema-only mode, ie,
20308 * user data in a configuration table is treated like schema data. This
20309 * seems appropriate since system data in a config table would get
20310 * reloaded by CREATE EXTENSION. If the extension is not listed in the
20311 * list of extensions to be included, none of its data is dumped.
20312 */
20314 {
20322
20323 /*
20324 * Check if this extension is listed as to include in the dump. If
20325 * not, any table data associated with it is discarded.
20326 */
20329 curext->dobj.catId.oid))
20330 continue;
20331
20332 /*
20333 * Check if this extension is listed as to exclude in the dump. If
20334 * yes, any table data associated with it is discarded.
20335 */
20338 curext->dobj.catId.oid))
20339 continue;
20340
20342 {
20344
20351
20353 {
20358
20361 continue;
20362
20363 /*
20364 * Tables of not-to-be-dumped extensions shouldn't be dumped
20365 * unless the table or its schema is explicitly included
20366 */
20368 {
20369 /* check table explicitly requested */
20372 configtbloid))
20374
20375 /* check table's schema explicitly requested */
20377 DUMP_COMPONENT_DATA)
20379 }
20380
20381 /* check table excluded by an exclusion switch */
20384 configtbloid))
20386
20387 /* check schema excluded by an exclusion switch */
20389 configtbl->dobj.namespace->dobj.catId.oid))
20391
20393 {
20396 {
20399 }
20400 }
20401 }
20402 }
20407 }
20408
20409 /*
20410 * Now that all the TableDataInfo objects have been created for all the
20411 * extensions, check their FK dependencies and register them to try and
20412 * dump the data out in an order that they can be restored in.
20413 *
20414 * Note that this is not a problem for user tables as their FKs are
20415 * recreated after the data has been loaded.
20416 */
20417
20418 query = createPQExpBuffer();
20419
20420 printfPQExpBuffer(query,
20421 "SELECT conrelid, confrelid "
20422 "FROM pg_constraint "
20423 "JOIN pg_depend ON (objid = confrelid) "
20424 "WHERE contype = 'f' "
20425 "AND refclassid = 'pg_extension'::regclass "
20426 "AND classid = 'pg_class'::regclass;");
20427
20429 ntups = PQntuples(res);
20430
20433
20434 /* Now get the dependencies and register them */
20436 {
20437 Oid conrelid,
20438 confrelid;
20440 *contable;
20441
20444 contable = findTableByOid(conrelid);
20446
20449 contable == NULL ||
20451 continue;
20452
20453 /*
20454 * Make referencing TABLE_DATA object depend on the referenced table's
20455 * TABLE_DATA object.
20456 */
20459 }
20460 PQclear(res);
20461 destroyPQExpBuffer(query);
20462}
20463
20464/*
20465 * getDependencies --- obtain available dependency data
20466 */
20467static void
20469{
20470 PQExpBuffer query;
20471 PGresult *res;
20472 int ntups,
20473 i;
20475 i_objid,
20476 i_refclassid,
20477 i_refobjid,
20478 i_deptype;
20479 DumpableObject *dobj,
20480 *refdobj;
20481
20483
20484 query = createPQExpBuffer();
20485
20486 /*
20487 * Messy query to collect the dependency data we need. Note that we
20488 * ignore the sub-object column, so that dependencies of or on a column
20489 * look the same as dependencies of or on a whole table.
20490 *
20491 * PIN dependencies aren't interesting, and EXTENSION dependencies were
20492 * already processed by getExtensionMembership.
20493 */
20495 "classid, objid, refclassid, refobjid, deptype "
20496 "FROM pg_depend "
20497 "WHERE deptype != 'p' AND deptype != 'e'\n");
20498
20499 /*
20500 * Since we don't treat pg_amop entries as separate DumpableObjects, we
20501 * have to translate their dependencies into dependencies of their parent
20502 * opfamily. Ignore internal dependencies though, as those will point to
20503 * their parent opclass, which we needn't consider here (and if we did,
20504 * it'd just result in circular dependencies). Also, "loose" opfamily
20505 * entries will have dependencies on their parent opfamily, which we
20506 * should drop since they'd likewise become useless self-dependencies.
20507 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
20508 */
20510 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
20511 "FROM pg_depend d, pg_amop o "
20512 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20513 "classid = 'pg_amop'::regclass AND objid = o.oid "
20514 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n");
20515
20516 /* Likewise for pg_amproc entries */
20518 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
20519 "FROM pg_depend d, pg_amproc p "
20520 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20521 "classid = 'pg_amproc'::regclass AND objid = p.oid "
20522 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n");
20523
20524 /*
20525 * Translate dependencies of pg_propgraph_element entries into
20526 * dependencies of their parent pg_class entry.
20527 */
20530 "SELECT 'pg_class'::regclass AS classid, pgepgid AS objid, refclassid, refobjid, deptype "
20531 "FROM pg_depend d, pg_propgraph_element pge "
20532 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20533 "classid = 'pg_propgraph_element'::regclass AND objid = pge.oid\n");
20534
20535 /* Sort the output for efficiency below */
20537
20539
20540 ntups = PQntuples(res);
20541
20547
20548 /*
20549 * Since we ordered the SELECT by referencing ID, we can expect that
20550 * multiple entries for the same object will appear together; this saves
20551 * on searches.
20552 */
20553 dobj = NULL;
20554
20556 {
20557 CatalogId objId;
20559 char deptype;
20560
20566
20570 dobj = findObjectByCatalogId(objId);
20571
20572 /*
20573 * Failure to find objects mentioned in pg_depend is not unexpected,
20574 * since for example we don't collect info about TOAST tables.
20575 */
20577 {
20578#ifdef NOT_USED
20581#endif
20582 continue;
20583 }
20584
20586
20588 {
20589#ifdef NOT_USED
20592#endif
20593 continue;
20594 }
20595
20596 /*
20597 * For 'x' dependencies, mark the object for later; we still add the
20598 * normal dependency, for possible ordering purposes. Currently
20599 * pg_dump_sort.c knows to put extensions ahead of all object types
20600 * that could possibly depend on them, but this is safer.
20601 */
20602 if (deptype == 'x')
20604
20605 /*
20606 * Ordinarily, table rowtypes have implicit dependencies on their
20607 * tables. However, for a composite type the implicit dependency goes
20608 * the other way in pg_depend; which is the right thing for DROP but
20609 * it doesn't produce the dependency ordering we need. So in that one
20610 * case, we reverse the direction of the dependency.
20611 */
20612 if (deptype == 'i' &&
20616 else
20617 /* normal case */
20619 }
20620
20621 PQclear(res);
20622
20623 destroyPQExpBuffer(query);
20624}
20625
20626
20627/*
20628 * createBoundaryObjects - create dummy DumpableObjects to represent
20629 * dump section boundaries.
20630 */
20633{
20635
20637
20642
20647
20649}
20650
20651/*
20652 * addBoundaryDependencies - add dependencies as needed to enforce the dump
20653 * section boundaries.
20654 */
20655static void
20658{
20662
20664 {
20666
20667 /*
20668 * The classification of object types here must match the SECTION_xxx
20669 * values assigned during subsequent ArchiveEntry calls!
20670 */
20672 {
20698 /* Pre-data objects: must come before the pre-data boundary */
20700 break;
20705 /* Data objects: must come between the boundaries */
20708 break;
20722 /* Post-data objects: must come after the post-data boundary */
20724 break;
20726 /* Rules are post-data, but only if dumped separately */
20729 break;
20732 /* Constraints are post-data, but only if dumped separately */
20735 break;
20737 /* nothing to do */
20738 break;
20740 /* must come after the pre-data boundary */
20742 break;
20744 /* stats section varies by parent object type, DATA or POST */
20746 {
20749 }
20750 else
20752 break;
20753 }
20754 }
20755}
20756
20757
20758/*
20759 * BuildArchiveDependencies - create dependency data for archive TOC entries
20760 *
20761 * The raw dependency data obtained by getDependencies() is not terribly
20762 * useful in an archive dump, because in many cases there are dependency
20763 * chains linking through objects that don't appear explicitly in the dump.
20764 * For example, a view will depend on its _RETURN rule while the _RETURN rule
20765 * will depend on other objects --- but the rule will not appear as a separate
20766 * object in the dump. We need to adjust the view's dependencies to include
20767 * whatever the rule depends on that is included in the dump.
20768 *
20769 * Just to make things more complicated, there are also "special" dependencies
20770 * such as the dependency of a TABLE DATA item on its TABLE, which we must
20771 * not rearrange because pg_restore knows that TABLE DATA only depends on
20772 * its table. In these cases we must leave the dependencies strictly as-is
20773 * even if they refer to not-to-be-dumped objects.
20774 *
20775 * To handle this, the convention is that "special" dependencies are created
20776 * during ArchiveEntry calls, and an archive TOC item that has any such
20777 * entries will not be touched here. Otherwise, we recursively search the
20778 * DumpableObject data structures to build the correct dependencies for each
20779 * archive TOC item.
20780 */
20781static void
20783{
20785 TocEntry *te;
20786
20787 /* Scan all TOC entries in the archive */
20789 {
20790 DumpableObject *dobj;
20791 DumpId *dependencies;
20792 int nDeps;
20793 int allocDeps;
20794
20795 /* No need to process entries that will not be dumped */
20797 continue;
20798 /* Ignore entries that already have "special" dependencies */
20800 continue;
20801 /* Otherwise, look up the item's original DumpableObject, if any */
20804 continue;
20805 /* No work if it has no dependencies */
20807 continue;
20808 /* Set up work array */
20809 allocDeps = 64;
20811 nDeps = 0;
20812 /* Recursively find all dumpable dependencies */
20813 findDumpableDependencies(AH, dobj,
20814 &dependencies, &nDeps, &allocDeps);
20815 /* And save 'em ... */
20816 if (nDeps > 0)
20817 {
20819 te->dependencies = dependencies;
20820 te->nDeps = nDeps;
20821 }
20822 else
20823 free(dependencies);
20824 }
20825}
20826
20827/* Recursive search subroutine for BuildArchiveDependencies */
20828static void
20831{
20833
20834 /*
20835 * Ignore section boundary objects: if we search through them, we'll
20836 * report lots of bogus dependencies.
20837 */
20840 return;
20841
20843 {
20845
20847 {
20848 /* Object will be dumped, so just reference it as a dependency */
20849 if (*nDeps >= *allocDeps)
20850 {
20851 *allocDeps *= 2;
20853 }
20854 (*dependencies)[*nDeps] = depid;
20855 (*nDeps)++;
20856 }
20857 else
20858 {
20859 /*
20860 * Object will not be dumped, so recursively consider its deps. We
20861 * rely on the assumption that sortDumpableObjects already broke
20862 * any dependency loops, else we might recurse infinitely.
20863 */
20865
20868 dependencies, nDeps, allocDeps);
20869 }
20870 }
20871}
20872
20873
20874/*
20875 * getFormattedTypeName - retrieve a nicely-formatted type name for the
20876 * given type OID.
20877 *
20878 * This does not guarantee to schema-qualify the output, so it should not
20879 * be used to create the target object name for CREATE or ALTER commands.
20880 *
20881 * Note that the result is cached and must not be freed by the caller.
20882 */
20883static const char *
20885{
20888 PQExpBuffer query;
20889 PGresult *res;
20890
20891 if (oid == 0)
20892 {
20894 return "*";
20896 return "NONE";
20897 }
20898
20899 /* see if we have the result cached in the type's TypeInfo record */
20903
20904 query = createPQExpBuffer();
20906 oid);
20907
20909
20910 /* result of format_type is already quoted */
20912
20913 PQclear(res);
20914 destroyPQExpBuffer(query);
20915
20916 /*
20917 * Cache the result for re-use in later requests, if possible. If we
20918 * don't have a TypeInfo for the type, the string will be leaked once the
20919 * caller is done with it ... but that case really should not happen, so
20920 * leaking if it does seems acceptable.
20921 */
20924
20926}
20927
20928/*
20929 * Return a column list clause for the given relation.
20930 *
20931 * Special case: if there are no undropped columns in the relation, return
20932 * "", not an invalid "()" column list.
20933 */
20934static const char *
20936{
20943
20947 {
20949 continue;
20951 continue;
20956 }
20957
20959 return ""; /* no undropped columns */
20960
20963}
20964
20965/*
20966 * Check if a reloptions array is nonempty.
20967 */
20968static bool
20970{
20971 /* Don't want to print it if it's just "{}" */
20973}
20974
20975/*
20976 * Format a reloptions array and append it to the given buffer.
20977 *
20978 * "prefix" is prepended to the option names; typically it's "" or "toast.".
20979 */
20980static void
20983{
20984 bool res;
20985
20988 if (!res)
20990}
20991
20992/*
20993 * read_dump_filters - retrieve object identifier patterns from file
20994 *
20995 * Parse the specified filter file for include and exclude patterns, and add
20996 * them to the relevant lists. If the filename is "-" then filters will be
20997 * read from STDIN rather than a file.
20998 */
20999static void
21001{
21003 char *objname;
21005 FilterObjectType objtype;
21006
21008
21010 {
21012 {
21013 switch (objtype)
21014 {
21016 break;
21024 "include",
21025 filter_object_type_name(objtype));
21026 exit_nicely(1);
21027 break; /* unreachable */
21028
21031 break;
21034 break;
21038 break;
21042 break;
21045 objname);
21047 break;
21048 }
21049 }
21051 {
21052 switch (objtype)
21053 {
21055 break;
21062 "exclude",
21063 filter_object_type_name(objtype));
21064 exit_nicely(1);
21065 break;
21066
21069 break;
21072 objname);
21073 break;
21076 objname);
21077 break;
21080 break;
21083 break;
21086 objname);
21087 break;
21088 }
21089 }
21090 else
21091 {
21094 }
21095
21096 if (objname)
21097 free(objname);
21098 }
21099
21101}
void recordAdditionalCatalogID(CatalogId catId, DumpableObject *dobj)
Definition common.c:722
void recordExtensionMembership(CatalogId catId, ExtensionInfo *ext)
Definition common.c:1066
void addObjectDependency(DumpableObject *dobj, DumpId refId)
Definition common.c:821
DumpableObject * findObjectByCatalogId(CatalogId catalogId)
Definition common.c:781
void getDumpableObjects(DumpableObject ***objs, int *numObjs)
Definition common.c:800
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:374
bool parse_compress_algorithm(char *name, pg_compress_algorithm *algorithm)
Definition compression.c:79
void parse_compress_specification(pg_compress_algorithm algorithm, char *specification, pg_compress_specification *result)
Definition compression.c:137
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:681
void makeAlterConfigCommand(PGconn *conn, const char *configitem, const char *type, const char *name, const char *type2, const char *name2, PQExpBuffer buf)
Definition dumputils.c:868
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:733
void quoteAclUserName(PQExpBuffer output, const char *input)
Definition dumputils.c:588
void emitShSecLabels(PGconn *conn, PGresult *res, PQExpBuffer buffer, const char *objtype, const char *objname)
Definition dumputils.c:699
const char * PQparameterStatus(const PGconn *conn, const char *paramName)
Definition fe-connect.c:7697
int PQsetClientEncoding(PGconn *conn, const char *encoding)
Definition fe-connect.c:7840
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 @177 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:290
enum _archiveFormat ArchiveFormat
void RestoreArchive(Archive *AHX, bool append_data)
Definition pg_backup_archiver.c:350
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:232
int archprintf(Archive *AH, const char *fmt,...) pg_attribute_printf(2
void SetArchiveOptions(Archive *AH, DumpOptions *dopt, RestoreOptions *ropt)
Definition pg_backup_archiver.c:277
void WriteData(Archive *AHX, const void *data, size_t dLen)
Definition pg_backup_archiver.c:1239
TocEntry * ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
Definition pg_backup_archiver.c:1260
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:1647
void getConstraints(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8388
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:16570
static void dumpAttrDef(Archive *fout, const AttrDefInfo *adinfo)
Definition pg_dump.c:18391
ExtensionInfo * getExtensions(Archive *fout, int *numExtensions)
Definition pg_dump.c:6215
static void selectDumpableProcLang(ProcLangInfo *plang, Archive *fout)
Definition pg_dump.c:2199
static void collectBinaryUpgradeClassOids(Archive *fout)
Definition pg_dump.c:5915
static PQExpBuffer createDummyViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17226
static void dumpUserMappings(Archive *fout, const char *servername, const char *namespace, const char *owner, CatalogId catalogId, DumpId dumpId)
Definition pg_dump.c:16384
static void dumpPublicationNamespace(Archive *fout, const PublicationSchemaInfo *pubsinfo)
Definition pg_dump.c:5015
static void addBoundaryDependencies(DumpableObject **dobjs, int numObjs, DumpableObject *boundaryObjs)
Definition pg_dump.c:20657
static void selectDumpableTable(TableInfo *tbinfo, Archive *fout)
Definition pg_dump.c:2068
static char * convertTSFunction(Archive *fout, Oid funcOid)
Definition pg_dump.c:14554
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:5728
static Oid get_next_possible_free_pg_type_oid(Archive *fout, PQExpBuffer upgrade_query)
Definition pg_dump.c:5773
static void dumpNamespace(Archive *fout, const NamespaceInfo *nspinfo)
Definition pg_dump.c:12016
static bool forcePartitionRootLoad(const TableInfo *tbinfo)
Definition pg_dump.c:2829
static void dumpBaseType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12609
static char * dumpRelationStats_dumper(Archive *fout, const void *userArg, const TocEntry *te)
Definition pg_dump.c:11246
static void dumpTSDictionary(Archive *fout, const TSDictInfo *dictinfo)
Definition pg_dump.c:15953
static void dumpRelationStats(Archive *fout, const RelStatsInfo *rsinfo)
Definition pg_dump.c:11533
static void dumpTableComment(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:11559
static SimpleStringList extension_include_patterns
Definition pg_dump.c:185
static void selectDumpableNamespace(NamespaceInfo *nsinfo, Archive *fout)
Definition pg_dump.c:1982
static void dumpTrigger(Archive *fout, const TriggerInfo *tginfo)
Definition pg_dump.c:19812
static void binary_upgrade_set_type_oids_by_rel(Archive *fout, PQExpBuffer upgrade_buffer, const TableInfo *tbinfo)
Definition pg_dump.c:5884
static PQExpBuffer createViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17177
static void dumpStatisticsExt(Archive *fout, const StatsExtInfo *statsextinfo)
Definition pg_dump.c:18675
void getPolicies(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4226
static void dumpRangeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12387
void getExtensionMembership(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:20195
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:11098
static char * getFormattedOperatorName(const char *oproid)
Definition pg_dump.c:14524
static char * format_function_signature(Archive *fout, const FuncInfo *finfo, bool honor_quotes)
Definition pg_dump.c:13579
static void dumpConstraint(Archive *fout, const ConstraintInfo *coninfo)
Definition pg_dump.c:19032
static void dumpTableAttach(Archive *fout, const TableAttachInfo *attachinfo)
Definition pg_dump.c:18323
static void dumpAccessMethod(Archive *fout, const AccessMethodInfo *aminfo)
Definition pg_dump.c:14576
static void selectDumpableStatisticsObject(StatsExtInfo *sobj, Archive *fout)
Definition pg_dump.c:2324
static void selectDumpablePublicationObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2306
static void dumpSequenceData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:19723
static void selectDumpableDefaultACL(DefaultACLInfo *dinfo, DumpOptions *dopt)
Definition pg_dump.c:2152
static void BuildArchiveDependencies(Archive *fout)
Definition pg_dump.c:20783
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:7200
void getOwnedSeqs(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7756
static void makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo)
Definition pg_dump.c:3026
static const char * getAttrName(int attrnum, const TableInfo *tblInfo)
Definition pg_dump.c:18452
static void dumpForeignServer(Archive *fout, const ForeignServerInfo *srvinfo)
Definition pg_dump.c:16284
static void appendReloptionsArrayAH(PQExpBuffer buffer, const char *reloptions, const char *prefix, Archive *fout)
Definition pg_dump.c:20982
static void dumpTableData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2857
static void prohibit_crossdb_refs(PGconn *conn, const char *dbname, const char *pattern)
Definition pg_dump.c:1907
static int dumpTableData_copy(Archive *fout, const void *dcontext)
Definition pg_dump.c:2364
static const char * getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts)
Definition pg_dump.c:20885
static void buildMatViewRefreshDependencies(Archive *fout)
Definition pg_dump.c:3116
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:5804
void getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4884
static void dumpShellType(Archive *fout, const ShellTypeInfo *stinfo)
Definition pg_dump.c:13378
static void refreshMatViewData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2972
static int findComments(Oid classoid, Oid objoid, CommentItem **items)
Definition pg_dump.c:11657
static SimpleStringList foreign_servers_include_patterns
Definition pg_dump.c:182
static void selectDumpableCast(CastInfo *cast, Archive *fout)
Definition pg_dump.c:2174
static void dumpPublication(Archive *fout, const PublicationInfo *pubinfo)
Definition pg_dump.c:4682
void getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7937
static void addConstrChildIdxDeps(DumpableObject *dobj, const IndxInfo *refidx)
Definition pg_dump.c:8547
static int findSecLabels(Oid classoid, Oid objoid, SecLabelItem **items)
Definition pg_dump.c:16860
static SimpleStringList table_include_patterns_and_children
Definition pg_dump.c:173
static char * convertRegProcReference(const char *proc)
Definition pg_dump.c:14483
static void getTableData(DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind)
Definition pg_dump.c:3007
void getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables)
Definition pg_dump.c:9331
static void getDomainConstraints(Archive *fout, TypeInfo *tyinfo)
Definition pg_dump.c:8570
static void dumpOpfamily(Archive *fout, const OpfamilyInfo *opfinfo)
Definition pg_dump.c:14925
static void dumpDefaultACL(Archive *fout, const DefaultACLInfo *daclinfo)
Definition pg_dump.c:16478
static void selectDumpableObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2342
static void dumpTSTemplate(Archive *fout, const TSTemplateInfo *tmplinfo)
Definition pg_dump.c:16033
static void dumpIndexAttach(Archive *fout, const IndexAttachInfo *attachinfo)
Definition pg_dump.c:18632
static void dumpSubscriptionTable(Archive *fout, const SubRelInfo *subrinfo)
Definition pg_dump.c:5494
static char * format_function_arguments(const FuncInfo *finfo, const char *funcargs, bool is_agg)
Definition pg_dump.c:13556
static void dumpTransform(Archive *fout, const TransformInfo *transform)
Definition pg_dump.c:14135
static void dumpPublicationTable(Archive *fout, const PublicationRelInfo *pubrinfo)
Definition pg_dump.c:5058
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:6039
static void dumpDumpableObject(Archive *fout, DumpableObject *dobj)
Definition pg_dump.c:11819
static void dumpDatabaseConfig(Archive *AH, PQExpBuffer outbuf, const char *dbname, Oid dboid)
Definition pg_dump.c:3781
static void setup_connection(Archive *AH, const char *dumpencoding, const char *dumpsnapshot, char *use_role)
Definition pg_dump.c:1399
static void dumpTableConstraintComment(Archive *fout, const ConstraintInfo *coninfo)
Definition pg_dump.c:19353
static void dumpUndefinedType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12545
static void selectDumpableAccessMethod(AccessMethodInfo *method, Archive *fout)
Definition pg_dump.c:2232
static const char * fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer)
Definition pg_dump.c:20936
static void expand_table_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names, bool with_child_tables)
Definition pg_dump.c:1811
static void findDumpableDependencies(ArchiveHandle *AH, const DumpableObject *dobj, DumpId **dependencies, int *nDeps, int *allocDeps)
Definition pg_dump.c:20830
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:10119
static void dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17266
static void dumpTSParser(Archive *fout, const TSParserInfo *prsinfo)
Definition pg_dump.c:15889
static void expand_foreign_server_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
Definition pg_dump.c:1759
static void dumpCompositeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:13083
static void dumpEnumType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12247
static void dumpExtension(Archive *fout, const ExtensionInfo *extinfo)
Definition pg_dump.c:12093
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:18752
static char * get_synchronized_snapshot(Archive *fout)
Definition pg_dump.c:1595
static void dumpSubscription(Archive *fout, const SubscriptionInfo *subinfo)
Definition pg_dump.c:5563
static void appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname, const char *argtype, const char *argval)
Definition pg_dump.c:11114
void processExtensionTables(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:20288
static void dumpEventTrigger(Archive *fout, const EventTriggerInfo *evtinfo)
Definition pg_dump.c:19938
static int BinaryUpgradeClassOidItemCmp(const void *p1, const void *p2)
Definition pg_dump.c:5899
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:10998
static SimpleStringList tabledata_exclude_patterns
Definition pg_dump.c:178
static void dumpConversion(Archive *fout, const ConvInfo *convinfo)
Definition pg_dump.c:15401
static void dumpForeignDataWrapper(Archive *fout, const FdwInfo *fdwinfo)
Definition pg_dump.c:16211
static void dumpProcLang(Archive *fout, const ProcLangInfo *plang)
Definition pg_dump.c:13424
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:16698
static void selectDumpableExtension(ExtensionInfo *extinfo, DumpOptions *dopt)
Definition pg_dump.c:2267
void getTriggers(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8779
static ArchiveFormat parseArchiveFormat(const char *format, ArchiveMode *mode)
Definition pg_dump.c:1609
static void read_dump_filters(const char *filename, DumpOptions *dopt)
Definition pg_dump.c:21001
static void dumpTSConfig(Archive *fout, const TSConfigInfo *cfginfo)
Definition pg_dump.c:16091
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:9226
static bool checkExtensionMembership(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:1932
static int dumpTableData_insert(Archive *fout, const void *dcontext)
Definition pg_dump.c:2535
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:5949
static void set_restrict_relation_kind(Archive *AH, const char *value)
Definition pg_dump.c:5138
static char * format_aggregate_signature(const AggInfo *agginfo, Archive *fout, bool honor_quotes)
Definition pg_dump.c:15497
static void dumpSequence(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:19469
bool shouldPrintColumn(const DumpOptions *dopt, const TableInfo *tbinfo, int colno)
Definition pg_dump.c:10246
static TableInfo * getRootTableInfo(const TableInfo *tbinfo)
Definition pg_dump.c:2804
static SimpleOidList foreign_servers_include_oids
Definition pg_dump.c:183
static void dumpCollation(Archive *fout, const CollInfo *collinfo)
Definition pg_dump.c:15144
static void dumpTableSecLabel(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:16778
static void dumpCompositeTypeColComments(Archive *fout, const TypeInfo *tyinfo, PGresult *res)
Definition pg_dump.c:13289
static void expand_extension_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
Definition pg_dump.c:1706
static void selectDumpableType(TypeInfo *tyinfo, Archive *fout)
Definition pg_dump.c:2107
static void dumpOpclass(Archive *fout, const OpclassInfo *opcinfo)
Definition pg_dump.c:14644
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
void simple_ptr_list_append(SimplePtrList *list, void *ptr)
Definition simple_list.c:162
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:1047
bool parsePGArray(const char *atext, char ***itemarray, int *nitems)
Definition string_utils.c:813
bool appendReloptionsArray(PQExpBuffer buffer, const char *reloptions, const char *prefix, int encoding, bool std_strings)
Definition string_utils.c:960
void appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
Definition string_utils.c:484
Definition pathnodes.h:3756
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:149
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:670
Definition pg_dump.h:702
Definition pg_dump.h:746
Definition pg_dump.h:712
Definition pg_dump.h:269
Definition pg_backup_archiver.h:205
Definition pg_dump.h:403
Definition pg_dump.h:544
Definition pg_dump.h:595
Definition pg_dump.h:290
Definition pg_dump.h:517
Definition pg_dump.h:297
Definition pg_dump.h:624
Definition pg_dump.h:580
Definition pg_backup.h:172
Definition pg_dump.h:169
Definition pg_dump.h:179
Definition pg_dump.h:148
Definition pg_dump.h:496
Definition pg_dump.h:194
Definition pg_dump.h:602
Definition pg_dump.h:613
Definition pg_dump.h:240
Definition pg_dump.h:442
Definition pg_dump.h:419
Definition pg_dump.h:564
Definition pg_dump.h:640
Definition pg_dump.h:185
Definition pg_dump.h:276
Definition pg_dump.h:283
Definition pg_dump.h:259
Definition pg_dump.h:655
Definition pg_dump.h:533
Definition pg_dump.h:570
Definition pg_dump.h:449
Definition pg_backup.h:98
pg_compress_specification compression_spec
Definition pg_backup.h:150
Definition pg_dump.h:476
Definition pg_dump.h:233
Definition pg_dump.h:468
Definition pg_dump.h:396
Definition pg_dump.h:412
Definition pg_dump.h:303
Definition pg_dump.h:588
Definition pg_backup_archiver.h:338
Definition pg_dump.h:554
Definition pg_dump.h:487
Definition pg_dump.h:204
Definition getopt_long.h:18
Definition compression.h:33
Definition libpq-int.h:374
Definition libpq-int.h:166
Definition oauth-curl.c:107
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition varlena.c:3063
◆ 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 20657 of file pg_dump.c.
20659{
20663
20665 {
20667
20668 /*
20669 * The classification of object types here must match the SECTION_xxx
20670 * values assigned during subsequent ArchiveEntry calls!
20671 */
20673 {
20699 /* Pre-data objects: must come before the pre-data boundary */
20701 break;
20706 /* Data objects: must come between the boundaries */
20709 break;
20723 /* Post-data objects: must come after the post-data boundary */
20725 break;
20727 /* Rules are post-data, but only if dumped separately */
20730 break;
20733 /* Constraints are post-data, but only if dumped separately */
20736 break;
20738 /* nothing to do */
20739 break;
20741 /* must come after the pre-data boundary */
20743 break;
20745 /* stats section varies by parent object type, DATA or POST */
20747 {
20750 }
20751 else
20753 break;
20754 }
20755 }
20756}
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 8547 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 5728 of file pg_dump.c.
5734{
5736 {
5738 PGresult *res;
5739 PQExpBuffer query;
5740 int ntups;
5743
5744 /* dodge fmtId() non-reentrancy */
5746
5747 query = createPQExpBuffer();
5748 appendPQExpBuffer(query,
5749 "SELECT e.extname "
5750 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5751 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5752 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5753 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5754 catalog,
5757 ntups = PQntuples(res);
5760 {
5762 keyword, nm,
5764 }
5765
5766 PQclear(res);
5767 destroyPQExpBuffer(query);
5769 }
5770}
References appendPQExpBuffer(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::depends_on_ext, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), fmtId(), fout, 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 11114 of file pg_dump.c.
11116{
11118
11121
11124}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, fb(), and fout.
Referenced by dumpRelationStats_dumper(), and dumpStatisticsExtStats().
◆ appendReloptionsArrayAH()
|
static |
Definition at line 20982 of file pg_dump.c.
20984{
20985 bool res;
20986
20989 if (!res)
20991}
References appendReloptionsArray(), Archive::encoding, fout, pg_log_warning, and Archive::std_strings.
Referenced by dumpConstraint(), dumpRule(), and dumpTableSchema().
◆ binary_upgrade_extension_member()
|
static |
Definition at line 6039 of file pg_dump.c.
6044{
6047
6049 return;
6050
6051 /*
6052 * Find the parent extension. We could avoid this search if we wanted to
6053 * add a link field to DumpableObject, but the space costs of that would
6054 * be considerable. We assume that member objects could only have a
6055 * direct dependency on their own extension, not any others.
6056 */
6058 {
6061 break;
6063 }
6066 objtype, objname);
6067
6069 "\n-- For binary upgrade, handle extension membership the hard way\n");
6072 objtype);
6076}
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 5949 of file pg_dump.c.
5951{
5953 BinaryUpgradeClassOidItem *entry;
5954
5956
5957 /*
5958 * Preserve the OID and relfilenumber of the table, table's index, table's
5959 * toast table and toast table's index if any.
5960 *
5961 * One complexity is that the current table definition might not require
5962 * the creation of a TOAST table, but the old database might have a TOAST
5963 * table that was created earlier, before some wide columns were dropped.
5964 * By setting the TOAST oid we force creation of the TOAST heap and index
5965 * by the new backend, so we can copy the files during binary upgrade
5966 * without worrying about this case.
5967 */
5971 BinaryUpgradeClassOidItemCmp);
5972
5974 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5975
5978 {
5980 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5981 pg_class_oid);
5982
5983 /*
5984 * Not every relation has storage. Also, in a pre-v12 database,
5985 * partitioned tables have a relfilenumber, which should not be
5986 * preserved when upgrading.
5987 */
5991 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5992 entry->relfilenumber);
5993
5994 /*
5995 * In a pre-v12 database, partitioned tables might be marked as having
5996 * toast tables, but we should ignore them if so.
5997 */
6000 {
6002 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
6003 entry->toast_oid);
6005 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
6006 entry->toast_relfilenumber);
6007
6008 /* every toast table has an index */
6010 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
6011 entry->toast_index_oid);
6013 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
6014 entry->toast_index_relfilenumber);
6015 }
6016 }
6017 else
6018 {
6019 /* Preserve the OID and relfilenumber of the index */
6021 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
6022 pg_class_oid);
6024 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
6025 entry->relfilenumber);
6026 }
6027
6029}
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 5884 of file pg_dump.c.
5887{
5889
5893}
References binary_upgrade_set_type_oids_by_type_oid(), fb(), fout, and OidIsValid.
Referenced by dumpTableSchema().
◆ binary_upgrade_set_type_oids_by_type_oid()
|
static |
Definition at line 5804 of file pg_dump.c.
5809{
5811 PGresult *res;
5816
5819 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5820 pg_type_oid);
5821
5825 else
5827
5830
5832 {
5834 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5836 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5837 pg_type_array_oid);
5838 }
5839
5840 /*
5841 * Pre-set the multirange type oid and its own array type oid.
5842 */
5844 {
5846 {
5848 "SELECT t.oid, t.typarray "
5849 "FROM pg_catalog.pg_type t "
5850 "JOIN pg_catalog.pg_range r "
5851 "ON t.oid = r.rngmultitypid "
5852 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5853 pg_type_oid);
5854
5856
5859
5860 PQclear(res);
5861 }
5862 else
5863 {
5866 }
5867
5869 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5871 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5872 pg_type_multirange_oid);
5874 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5876 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5877 pg_type_multirange_array_oid);
5878 }
5879
5881}
References appendPQExpBuffer(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), findTypeByOid(), fout, get_next_possible_free_pg_type_oid(), InvalidOid, OidIsValid, PQclear, PQfnumber(), PQgetvalue, printfPQExpBuffer(), Archive::remoteVersion, and tinfo.
Referenced by binary_upgrade_set_type_oids_by_rel(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), dumpShellType(), and dumpUndefinedType().
◆ BinaryUpgradeClassOidItemCmp()
Definition at line 5899 of file pg_dump.c.
5900{
5903
5905}
References fb(), BinaryUpgradeClassOidItem::oid, and pg_cmp_u32().
Referenced by binary_upgrade_set_pg_class_oids().
◆ BuildArchiveDependencies()
Definition at line 20783 of file pg_dump.c.
20784{
20786 TocEntry *te;
20787
20788 /* Scan all TOC entries in the archive */
20790 {
20791 DumpableObject *dobj;
20792 DumpId *dependencies;
20793 int nDeps;
20794 int allocDeps;
20795
20796 /* No need to process entries that will not be dumped */
20798 continue;
20799 /* Ignore entries that already have "special" dependencies */
20801 continue;
20802 /* Otherwise, look up the item's original DumpableObject, if any */
20805 continue;
20806 /* No work if it has no dependencies */
20808 continue;
20809 /* Set up work array */
20810 allocDeps = 64;
20812 nDeps = 0;
20813 /* Recursively find all dumpable dependencies */
20814 findDumpableDependencies(AH, dobj,
20815 &dependencies, &nDeps, &allocDeps);
20816 /* And save 'em ... */
20817 if (nDeps > 0)
20818 {
20820 te->dependencies = dependencies;
20821 te->nDeps = nDeps;
20822 }
20823 else
20824 free(dependencies);
20825 }
20826}
References _tocEntry::dependencies, _tocEntry::dumpId, fb(), findDumpableDependencies(), findObjectByDumpId(), fout, free, _tocEntry::nDeps, _dumpableObject::nDeps, _tocEntry::next, pg_malloc_array, pg_realloc_array, _tocEntry::reqs, and _archiveHandle::toc.
Referenced by main().
◆ buildMatViewRefreshDependencies()
Definition at line 3116 of file pg_dump.c.
3117{
3118 PQExpBuffer query;
3119 PGresult *res;
3120 int ntups,
3121 i;
3123 i_objid,
3124 i_refobjid;
3125
3126 /* No Mat Views before 9.3. */
3128 return;
3129
3130 query = createPQExpBuffer();
3131
3133 "( "
3134 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3135 "FROM pg_depend d1 "
3136 "JOIN pg_class c1 ON c1.oid = d1.objid "
3138 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3139 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3140 "AND d2.objid = r1.oid "
3141 "AND d2.refobjid <> d1.objid "
3142 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3145 "WHERE d1.classid = 'pg_class'::regclass "
3146 "UNION "
3147 "SELECT w.objid, d3.refobjid, c3.relkind "
3148 "FROM w "
3149 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3150 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3151 "AND d3.objid = r3.oid "
3152 "AND d3.refobjid <> w.refobjid "
3153 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3156 ") "
3157 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3158 "FROM w "
3160
3162
3163 ntups = PQntuples(res);
3164
3168
3170 {
3171 CatalogId objId;
3173 DumpableObject *dobj;
3177
3182
3183 dobj = findObjectByCatalogId(objId);
3185 continue;
3186
3192 continue;
3194
3197 continue;
3198
3204 continue;
3206
3208
3211 }
3212
3213 PQclear(res);
3214
3215 destroyPQExpBuffer(query);
3216}
References addObjectDependency(), appendPQExpBufferStr(), Assert, atooid, CppAsString2, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_REFRESH_MATVIEW, DO_TABLE, _dumpableObject::dumpId, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), fout, i, _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, Archive::remoteVersion, and CatalogId::tableoid.
Referenced by main().
◆ checkExtensionMembership()
|
static |
Definition at line 1932 of file pg_dump.c.
1933{
1935
1937 return false;
1938
1940
1941 /* Record dependency so that getDependencies needn't deal with that */
1943
1944 /*
1945 * In 9.6 and above, mark the member object to have any non-initial ACLs
1946 * dumped. (Any initial ACLs will be removed later, using data from
1947 * pg_init_privs, so that we'll dump only the delta from the extension's
1948 * initial setup.)
1949 *
1950 * Prior to 9.6, we do not include any extension member components.
1951 *
1952 * In binary upgrades, we still dump all components of the members
1953 * individually, since the idea is to exactly reproduce the database
1954 * contents rather than replace the extension contents with something
1955 * different.
1956 *
1957 * Note: it might be interesting someday to implement storage and delta
1958 * dumping of extension members' RLS policies and/or security labels.
1959 * However there is a pitfall for RLS policies: trying to dump them
1960 * requires getting a lock on their tables, and the calling user might not
1961 * have privileges for that. We need no lock to examine a table's ACLs,
1962 * so the current feature doesn't have a problem of that sort.
1963 */
1966 else
1967 {
1970 else
1972 }
1973
1974 return true;
1975}
References addObjectDependency(), _dumpOptions::binary_upgrade, _dumpableObject::catId, _extensionInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_NONE, _dumpableObject::dump_contains, _dumpableObject::dumpId, _dumpableObject::ext_member, fb(), findOwningExtension(), fout, and Archive::remoteVersion.
Referenced by selectDumpableAccessMethod(), selectDumpableCast(), selectDumpableNamespace(), selectDumpableObject(), selectDumpableProcLang(), selectDumpablePublicationObject(), selectDumpableStatisticsObject(), selectDumpableTable(), and selectDumpableType().
◆ collectBinaryUpgradeClassOids()
Definition at line 5915 of file pg_dump.c.
5916{
5917 PGresult *res;
5918 const char *query;
5919
5920 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5921 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5922 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5923 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5924 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5925 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5926 "ORDER BY c.oid;";
5927
5929
5931 binaryUpgradeClassOids =
5933
5935 {
5943 }
5944
5945 PQclear(res);
5946}
References atooid, binaryUpgradeClassOids, ExecuteSqlQuery(), fout, i, nbinaryUpgradeClassOids, BinaryUpgradeClassOidItem::oid, pg_malloc_array, 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 11734 of file pg_dump.c.
11735{
11736 PGresult *res;
11737 PQExpBuffer query;
11742 int ntups;
11744 DumpableObject *dobj;
11745
11746 query = createPQExpBuffer();
11747
11749 "FROM pg_catalog.pg_description "
11750 "ORDER BY classoid, objoid, objsubid");
11751
11753
11754 /* Construct lookup table containing OIDs in numeric form */
11755
11760
11761 ntups = PQntuples(res);
11762
11764 ncomments = 0;
11765 dobj = NULL;
11766
11768 {
11769 CatalogId objId;
11770 int subid;
11771
11775
11776 /* We needn't remember comments that don't match any dumpable object */
11780 dobj = findObjectByCatalogId(objId);
11782 continue;
11783
11784 /*
11785 * Comments on columns of composite types are linked to the type's
11786 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11787 * in the type's own DumpableObject.
11788 */
11791 {
11793
11797 }
11798 else
11799 dobj->components |= DUMP_COMPONENT_COMMENT;
11800
11805 ncomments++;
11806 }
11807
11808 PQclear(res);
11809 destroyPQExpBuffer(query);
11810}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, CommentItem::classoid, comments, createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_COMMENT, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), fout, i, ncomments, CommentItem::objoid, CommentItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc_array, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ collectRoleNames()
Definition at line 10834 of file pg_dump.c.
10835{
10836 PGresult *res;
10837 const char *query;
10839
10840 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10841
10843
10845
10847
10849 {
10852 }
10853
10854 PQclear(res);
10855}
References atooid, ExecuteSqlQuery(), fout, i, nrolenames, pg_malloc_array, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQntuples, RoleNameItem::rolename, rolenames, and RoleNameItem::roleoid.
Referenced by main().
◆ collectSecLabels()
Definition at line 16939 of file pg_dump.c.
16940{
16941 PGresult *res;
16942 PQExpBuffer query;
16948 int ntups;
16950 DumpableObject *dobj;
16951
16952 query = createPQExpBuffer();
16953
16954 appendPQExpBufferStr(query,
16955 "SELECT label, provider, classoid, objoid, objsubid "
16956 "FROM pg_catalog.pg_seclabels "
16957 "ORDER BY classoid, objoid, objsubid");
16958
16960
16961 /* Construct lookup table containing OIDs in numeric form */
16967
16968 ntups = PQntuples(res);
16969
16971 nseclabels = 0;
16972 dobj = NULL;
16973
16975 {
16976 CatalogId objId;
16977 int subid;
16978
16982
16983 /* We needn't remember labels that don't match any dumpable object */
16987 dobj = findObjectByCatalogId(objId);
16989 continue;
16990
16991 /*
16992 * Labels on columns of composite types are linked to the type's
16993 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16994 * in the type's own DumpableObject.
16995 */
16998 {
17000
17004 }
17005 else
17006 dobj->components |= DUMP_COMPONENT_SECLABEL;
17007
17013 nseclabels++;
17014 }
17015
17016 PQclear(res);
17017 destroyPQExpBuffer(query);
17018}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, SecLabelItem::classoid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_SECLABEL, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), fout, i, SecLabelItem::label, nseclabels, SecLabelItem::objoid, SecLabelItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc_array, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, SecLabelItem::provider, seclabels, and CatalogId::tableoid.
Referenced by main().
◆ collectSequences()
Definition at line 19407 of file pg_dump.c.
19408{
19409 PGresult *res;
19410 const char *query;
19411
19412 /*
19413 * Before Postgres 10, sequence metadata is in the sequence itself. With
19414 * some extra effort, we might be able to use the sorted table for those
19415 * versions, but for now it seems unlikely to be worth it.
19416 *
19417 * Since version 18, we can gather the sequence data in this query with
19418 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19419 */
19421 return;
19424 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19425 "seqstart, seqincrement, "
19426 "seqmax, seqmin, "
19427 "seqcache, seqcycle, "
19428 "NULL, 'f' "
19429 "FROM pg_catalog.pg_sequence "
19430 "ORDER BY seqrelid";
19431 else
19432 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19433 "seqstart, seqincrement, "
19434 "seqmax, seqmin, "
19435 "seqcache, seqcycle, "
19436 "last_value, is_called "
19437 "FROM pg_catalog.pg_sequence, "
19438 "pg_get_sequence_data(seqrelid) "
19439 "ORDER BY seqrelid;";
19440
19442
19445
19447 {
19459 }
19460
19461 PQclear(res);
19462}
References atooid, SequenceItem::cache, SequenceItem::cycled, Archive::dopt, _dumpOptions::dumpData, ExecuteSqlQuery(), fb(), fout, i, SequenceItem::incby, SequenceItem::is_called, SequenceItem::last_value, SequenceItem::maxv, SequenceItem::minv, nsequences, SequenceItem::null_seqtuple, SequenceItem::oid, parse_sequence_type(), pg_malloc_array, PGRES_TUPLES_OK, PQclear, PQgetisnull, PQgetvalue, PQntuples, Archive::remoteVersion, SequenceItem::seqtype, _dumpOptions::sequence_data, sequences, and SequenceItem::startv.
Referenced by main().
◆ convertRegProcReference()
◆ convertTSFunction()
Definition at line 14554 of file pg_dump.c.
14555{
14557 char query[128];
14558 PGresult *res;
14559
14561 "SELECT '%u'::pg_catalog.regproc", funcOid);
14563
14565
14566 PQclear(res);
14567
14569}
References ExecuteSqlQueryForSingleRow(), fout, pg_strdup(), PQclear, PQgetvalue, result, and snprintf.
Referenced by dumpTSParser(), and dumpTSTemplate().
◆ createBoundaryObjects()
|
static |
Definition at line 20633 of file pg_dump.c.
20634{
20636
20638
20643
20648
20650}
References AssignDumpId(), DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, fb(), nilCatalogId, pg_malloc_array, and pg_strdup().
Referenced by main().
◆ createDummyViewAsClause()
|
static |
Definition at line 17226 of file pg_dump.c.
17227{
17230
17232
17234 {
17238
17240
17241 /*
17242 * Must add collation if not default for the type, because CREATE OR
17243 * REPLACE VIEW won't change it
17244 */
17246 {
17247 CollInfo *coll;
17248
17250 if (coll)
17252 fmtQualifiedDumpable(coll));
17253 }
17254
17256 }
17257
17259}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, j, OidIsValid, and result.
Referenced by dumpRule(), and dumpTableSchema().
◆ createViewAsClause()
|
static |
Definition at line 17177 of file pg_dump.c.
17178{
17181 PGresult *res;
17183
17184 /* Fetch the view definition */
17185 appendPQExpBuffer(query,
17186 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
17187 tbinfo->dobj.catId.oid);
17188
17190
17192 {
17195 tbinfo->dobj.name);
17196 else
17198 tbinfo->dobj.name);
17199 }
17200
17202
17205 tbinfo->dobj.name);
17206
17207 /* Strip off the trailing semicolon so that other things may follow. */
17210
17211 PQclear(res);
17212 destroyPQExpBuffer(query);
17213
17215}
References appendBinaryPQExpBuffer(), appendPQExpBuffer(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), fout, len, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetlength, PQgetvalue, PQntuples, and result.
Referenced by dumpRule(), and dumpTableSchema().
◆ determineNotNullFlags()
|
static |
Definition at line 10119 of file pg_dump.c.
10127{
10129
10130 /*
10131 * If this not-null constraint is not valid, list its OID in
10132 * invalidnotnulloids and do nothing further. It'll be processed
10133 * elsewhere later.
10134 *
10135 * Because invalid not-null constraints are rare, we don't want to malloc
10136 * invalidnotnulloids until we're sure we're going it need it, which
10137 * happens here.
10138 */
10140 {
10142
10144 {
10148 }
10149 else
10151
10152 /*
10153 * Track when a parent constraint is invalid for the cases where a
10154 * child constraint has been validated independenly.
10155 */
10157
10158 /* nothing else to do */
10160 return;
10161 }
10162
10163 /*
10164 * notnull_noinh is straight from the query result. notnull_islocal also,
10165 * though flagInhAttrs may change that one later.
10166 */
10170
10171 /*
10172 * Determine a constraint name to use. If the column is not marked not-
10173 * null, we set NULL which cues ... to do nothing. An empty string says
10174 * to print an unnamed NOT NULL, and anything else is a constraint name to
10175 * use.
10176 */
10178 {
10179 /*
10180 * < 18 doesn't have not-null names, so an unnamed constraint is
10181 * sufficient.
10182 */
10185 else
10187 }
10188 else
10189 {
10192 else
10193 {
10194 /*
10195 * In binary upgrade of inheritance child tables, must have a
10196 * constraint name that we can UPDATE later; same if there's a
10197 * comment on the constraint.
10198 */
10200 !tbinfo->ispartition &&
10203 {
10206 }
10207 else
10208 {
10210
10211 /* XXX should match ChooseConstraintName better */
10217 else
10218 {
10221 }
10223 }
10224 }
10225 }
10226}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _dumpOptions::binary_upgrade, createPQExpBuffer(), Archive::dopt, fb(), fout, free, j, PQgetisnull, PQgetvalue, psprintf(), pstrdup(), and Archive::remoteVersion.
Referenced by getTableAttrs().
◆ dumpAccessMethod()
|
static |
Definition at line 14576 of file pg_dump.c.
14577{
14579 PQExpBuffer q;
14582
14583 /* Do nothing if not dumping schema */
14585 return;
14586
14587 q = createPQExpBuffer();
14589
14591
14593
14595 {
14598 break;
14601 break;
14602 default:
14605 destroyPQExpBuffer(q);
14608 return;
14609 }
14610
14612
14614 qamname);
14615
14619
14623 .description = "ACCESS METHOD",
14624 .section = SECTION_PRE_DATA,
14625 .createStmt = q->data,
14626 .dropStmt = delq->data));
14627
14628 /* Dump Access Method Comments */
14633
14634 destroyPQExpBuffer(q);
14637}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), Archive::dopt, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), fout, free, pg_log_warning, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpACL()
|
static |
Definition at line 16570 of file pg_dump.c.
16574{
16582 PQExpBuffer sql;
16583
16584 /* Do nothing if ACL dump is not enabled */
16587
16588 /* --data-only skips ACLs *except* large object ACLs */
16591
16592 sql = createPQExpBuffer();
16593
16594 /*
16595 * In binary upgrade mode, we don't run an extension's script but instead
16596 * dump out the objects independently and then recreate them. To preserve
16597 * any initial privileges which were set on extension objects, we need to
16598 * compute the set of GRANT and REVOKE commands necessary to get from the
16599 * default privileges of an object to its initial privileges as recorded
16600 * in pg_init_privs.
16601 *
16602 * At restore time, we apply these commands after having called
16603 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16604 * copy the results into pg_init_privs. This is how we preserve the
16605 * contents of that catalog across binary upgrades.
16606 */
16608 initprivs && *initprivs != '\0')
16609 {
16612 initprivs, acldefault, owner,
16616 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16617 }
16618
16619 /*
16620 * Now figure the GRANT and REVOKE commands needed to get to the object's
16621 * actual current ACL, starting from the initprivs if given, else from the
16622 * object-type-specific default. Also, while buildACLCommands will assume
16623 * that a NULL/empty acls string means it needn't do anything, what that
16624 * actually represents is the object-type-specific default; so we need to
16625 * substitute the acldefault string to get the right results in that case.
16626 */
16627 if (initprivs && *initprivs != '\0')
16628 {
16629 baseacls = initprivs;
16632 }
16633 else
16635
16641
16643 {
16646 int nDeps = 0;
16647
16648 if (tag)
16652 else
16654
16658
16660
16663 .namespace = nspname,
16664 .owner = owner,
16665 .description = "ACL",
16666 .section = SECTION_NONE,
16667 .createStmt = sql->data,
16668 .deps = aclDeps,
16669 .nDeps = nDeps));
16670
16672 }
16673
16674 destroyPQExpBuffer(sql);
16675
16677}
References _dumpableAcl::acl, acldefault(), _dumpableAcl::acldefault, _dumpOptions::aclsSkip, appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, buildACLCommands(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), Archive::dopt, _dumpOptions::dumpSchema, fb(), fout, _dumpableAcl::initprivs, InvalidDumpId, PQExpBufferData::len, name, nilCatalogId, pg_fatal, _dumpableAcl::privtype, Archive::remoteVersion, 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 15529 of file pg_dump.c.
15530{
15532 PQExpBuffer query;
15533 PQExpBuffer q;
15535 PQExpBuffer details;
15539 PGresult *res;
15554 const char *aggsortop;
15557 const char *aggtranstype;
15558 const char *aggtransspace;
15565
15566 /* Do nothing if not dumping schema */
15568 return;
15569
15570 query = createPQExpBuffer();
15571 q = createPQExpBuffer();
15573 details = createPQExpBuffer();
15574
15576 {
15577 /* Set up query for aggregate-specific details */
15578 appendPQExpBufferStr(query,
15579 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15580
15581 appendPQExpBufferStr(query,
15582 "SELECT "
15583 "aggtransfn,\n"
15584 "aggfinalfn,\n"
15585 "aggtranstype::pg_catalog.regtype,\n"
15586 "agginitval,\n"
15587 "aggsortop,\n"
15588 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15589 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15590
15592 appendPQExpBufferStr(query,
15593 "aggkind,\n"
15594 "aggmtransfn,\n"
15595 "aggminvtransfn,\n"
15596 "aggmfinalfn,\n"
15597 "aggmtranstype::pg_catalog.regtype,\n"
15598 "aggfinalextra,\n"
15599 "aggmfinalextra,\n"
15600 "aggtransspace,\n"
15601 "aggmtransspace,\n"
15602 "aggminitval,\n");
15603 else
15604 appendPQExpBufferStr(query,
15605 "'n' AS aggkind,\n"
15606 "'-' AS aggmtransfn,\n"
15607 "'-' AS aggminvtransfn,\n"
15608 "'-' AS aggmfinalfn,\n"
15609 "0 AS aggmtranstype,\n"
15610 "false AS aggfinalextra,\n"
15611 "false AS aggmfinalextra,\n"
15612 "0 AS aggtransspace,\n"
15613 "0 AS aggmtransspace,\n"
15614 "NULL AS aggminitval,\n");
15615
15617 appendPQExpBufferStr(query,
15618 "aggcombinefn,\n"
15619 "aggserialfn,\n"
15620 "aggdeserialfn,\n"
15621 "proparallel,\n");
15622 else
15623 appendPQExpBufferStr(query,
15624 "'-' AS aggcombinefn,\n"
15625 "'-' AS aggserialfn,\n"
15626 "'-' AS aggdeserialfn,\n"
15627 "'u' AS proparallel,\n");
15628
15630 appendPQExpBufferStr(query,
15631 "aggfinalmodify,\n"
15632 "aggmfinalmodify\n");
15633 else
15634 appendPQExpBufferStr(query,
15635 "'0' AS aggfinalmodify,\n"
15636 "'0' AS aggmfinalmodify\n");
15637
15638 appendPQExpBufferStr(query,
15639 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15640 "WHERE a.aggfnoid = p.oid "
15641 "AND p.oid = $1");
15642
15644
15646 }
15647
15648 printfPQExpBuffer(query,
15649 "EXECUTE dumpAgg('%u')",
15650 agginfo->aggfn.dobj.catId.oid);
15651
15653
15656
15669 aggsortop =