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 10, and up to any minor release of
980 * our own major version. (See also version check in pg_dumpall.c.)
981 */
982 fout->minRemoteVersion = 100000;
984
985 fout->numWorkers = numWorkers;
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 */
1497
1498 /*
1499 * Quote all identifiers, if requested.
1500 */
1503
1504 /*
1505 * Adjust row-security mode, if supported.
1506 */
1509 else
1511
1512 /*
1513 * For security reasons, we restrict the expansion of non-system views and
1514 * access to foreign tables during the pg_dump process. This restriction
1515 * is adjusted when dumping foreign table data.
1516 */
1518
1519 /*
1520 * Initialize prepared-query state to "nothing prepared". We do this here
1521 * so that a parallel dump worker will have its own state.
1522 */
1524
1525 /*
1526 * Start transaction-snapshot mode transaction to dump consistent data.
1527 */
1529
1530 /*
1531 * To support the combination of serializable_deferrable with the jobs
1532 * option we use REPEATABLE READ for the worker connections that are
1533 * passed a snapshot. As long as the snapshot is acquired in a
1534 * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
1535 * REPEATABLE READ transaction provides the appropriate integrity
1536 * guarantees. This is a kluge, but safe for back-patching.
1537 */
1539 ExecuteSqlStatement(AH,
1540 "SET TRANSACTION ISOLATION LEVEL "
1541 "SERIALIZABLE, READ ONLY, DEFERRABLE");
1542 else
1543 ExecuteSqlStatement(AH,
1544 "SET TRANSACTION ISOLATION LEVEL "
1545 "REPEATABLE READ, READ ONLY");
1546
1547 /*
1548 * If user specified a snapshot to use, select that. In a parallel dump
1549 * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
1550 * is already set (if the server can handle it) and we should use that.
1551 */
1554
1556 {
1558
1562 destroyPQExpBuffer(query);
1563 }
1566}
1567
1568/* Set up connection for a parallel worker process */
1569static void
1571{
1572 /*
1573 * We want to re-select all the same values the leader connection is
1574 * using. We'll have inherited directly-usable values in
1575 * AH->sync_snapshot_id and AH->use_role, but we need to translate the
1576 * inherited encoding value back to a string to pass to setup_connection.
1577 */
1578 setup_connection(AH,
1580 NULL,
1581 NULL);
1582}
1583
1584static char *
1586{
1587 char *query = "SELECT pg_catalog.pg_export_snapshot()";
1589 PGresult *res;
1590
1593 PQclear(res);
1594
1596}
1597
1600{
1602
1604
1606 {
1607 /* This is used by pg_dumpall, and is not documented */
1610 }
1627 else
1630}
1631
1632/*
1633 * Find the OIDs of all schemas matching the given list of patterns,
1634 * and append them to the given OID list.
1635 */
1636static void
1639 SimpleOidList *oids,
1641{
1642 PQExpBuffer query;
1643 PGresult *res;
1644 SimpleStringListCell *cell;
1646
1648 return; /* nothing to do */
1649
1650 query = createPQExpBuffer();
1651
1652 /*
1653 * The loop below runs multiple SELECTs might sometimes result in
1654 * duplicate entries in the OID list, but we don't care.
1655 */
1656
1658 {
1661
1662 appendPQExpBufferStr(query,
1663 "SELECT oid FROM pg_catalog.pg_namespace n\n");
1667 &dotcnt);
1670 cell->val);
1674
1678
1680 {
1682 }
1683
1684 PQclear(res);
1685 resetPQExpBuffer(query);
1686 }
1687
1688 destroyPQExpBuffer(query);
1689}
1690
1691/*
1692 * Find the OIDs of all extensions matching the given list of patterns,
1693 * and append them to the given OID list.
1694 */
1695static void
1698 SimpleOidList *oids,
1700{
1701 PQExpBuffer query;
1702 PGresult *res;
1703 SimpleStringListCell *cell;
1705
1707 return; /* nothing to do */
1708
1709 query = createPQExpBuffer();
1710
1711 /*
1712 * The loop below runs multiple SELECTs might sometimes result in
1713 * duplicate entries in the OID list, but we don't care.
1714 */
1716 {
1718
1719 appendPQExpBufferStr(query,
1720 "SELECT oid FROM pg_catalog.pg_extension e\n");
1723 &dotcnt);
1726 cell->val);
1727
1731
1733 {
1735 }
1736
1737 PQclear(res);
1738 resetPQExpBuffer(query);
1739 }
1740
1741 destroyPQExpBuffer(query);
1742}
1743
1744/*
1745 * Find the OIDs of all foreign servers matching the given list of patterns,
1746 * and append them to the given OID list.
1747 */
1748static void
1751 SimpleOidList *oids)
1752{
1753 PQExpBuffer query;
1754 PGresult *res;
1755 SimpleStringListCell *cell;
1757
1759 return; /* nothing to do */
1760
1761 query = createPQExpBuffer();
1762
1763 /*
1764 * The loop below runs multiple SELECTs might sometimes result in
1765 * duplicate entries in the OID list, but we don't care.
1766 */
1767
1769 {
1771
1772 appendPQExpBufferStr(query,
1773 "SELECT oid FROM pg_catalog.pg_foreign_server s\n");
1776 &dotcnt);
1779 cell->val);
1780
1784
1787
1788 PQclear(res);
1789 resetPQExpBuffer(query);
1790 }
1791
1792 destroyPQExpBuffer(query);
1793}
1794
1795/*
1796 * Find the OIDs of all tables matching the given list of patterns,
1797 * and append them to the given OID list. See also expand_dbname_patterns()
1798 * in pg_dumpall.c
1799 */
1800static void
1804{
1805 PQExpBuffer query;
1806 PGresult *res;
1807 SimpleStringListCell *cell;
1809
1811 return; /* nothing to do */
1812
1813 query = createPQExpBuffer();
1814
1815 /*
1816 * this might sometimes result in duplicate entries in the OID list, but
1817 * we don't care.
1818 */
1819
1821 {
1824
1825 /*
1826 * Query must remain ABSOLUTELY devoid of unqualified names. This
1827 * would be unnecessary given a pg_table_is_visible() variant taking a
1828 * search_path argument.
1829 *
1830 * For with_child_tables, we start with the basic query's results and
1831 * recursively search the inheritance tree to add child tables.
1832 */
1834 {
1836 }
1837
1838 appendPQExpBuffer(query,
1839 "SELECT c.oid"
1840 "\nFROM pg_catalog.pg_class c"
1841 "\n LEFT JOIN pg_catalog.pg_namespace n"
1842 "\n ON n.oid OPERATOR(pg_catalog.=) c.relnamespace"
1843 "\nWHERE c.relkind OPERATOR(pg_catalog.=) ANY"
1844 "\n (array['%c', '%c', '%c', '%c', '%c', '%c', '%c'])\n",
1852 &dotcnt);
1855 cell->val);
1859
1861 {
1863 "\nSELECT i.inhrelid"
1864 "\nFROM partition_tree p"
1865 "\n JOIN pg_catalog.pg_inherits i"
1866 "\n ON p.relid OPERATOR(pg_catalog.=) i.inhparent"
1867 "\n)"
1868 "\nSELECT relid FROM partition_tree");
1869 }
1870
1874 ALWAYS_SECURE_SEARCH_PATH_SQL));
1877
1879 {
1881 }
1882
1883 PQclear(res);
1884 resetPQExpBuffer(query);
1885 }
1886
1887 destroyPQExpBuffer(query);
1888}
1889
1890/*
1891 * Verifies that the connected database name matches the given database name,
1892 * and if not, dies with an error about the given pattern.
1893 *
1894 * The 'dbname' argument should be a literal name parsed from 'pattern'.
1895 */
1896static void
1898{
1899 const char *db;
1900
1904
1907 pattern);
1908}
1909
1910/*
1911 * checkExtensionMembership
1912 * Determine whether object is an extension member, and if so,
1913 * record an appropriate dependency and set the object's dump flag.
1914 *
1915 * It's important to call this for each object that could be an extension
1916 * member. Generally, we integrate this with determining the object's
1917 * to-be-dumped-ness, since extension membership overrides other rules for that.
1918 *
1919 * Returns true if object is an extension member, else false.
1920 */
1921static bool
1923{
1925
1927 return false;
1928
1930
1931 /* Record dependency so that getDependencies needn't deal with that */
1933
1934 /*
1935 * Mark the member object to have any non-initial ACLs dumped. (Any
1936 * initial ACLs will be removed later, using data from pg_init_privs, so
1937 * that we'll dump only the delta from the extension's initial setup.)
1938 *
1939 * In binary upgrades, we still dump all components of the members
1940 * individually, since the idea is to exactly reproduce the database
1941 * contents rather than replace the extension contents with something
1942 * different.
1943 *
1944 * Note: it might be interesting someday to implement storage and delta
1945 * dumping of extension members' RLS policies and/or security labels.
1946 * However there is a pitfall for RLS policies: trying to dump them
1947 * requires getting a lock on their tables, and the calling user might not
1948 * have privileges for that. We need no lock to examine a table's ACLs,
1949 * so the current feature doesn't have a problem of that sort.
1950 */
1953 else
1955
1956 return true;
1957}
1958
1959/*
1960 * selectDumpableNamespace: policy-setting subroutine
1961 * Mark a namespace as to be dumped or not
1962 */
1963static void
1965{
1966 /*
1967 * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
1968 * and (for --clean) a DROP SCHEMA statement. (In the absence of
1969 * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
1970 */
1972
1973 /*
1974 * If specific tables are being dumped, do not dump any complete
1975 * namespaces. If specific namespaces are being dumped, dump just those
1976 * namespaces. Otherwise, dump all non-system namespaces.
1977 */
1983 nsinfo->dobj.catId.oid) ?
1986 {
1987 /*
1988 * We dump out any ACLs defined in pg_catalog, if they are interesting
1989 * (and not the original ACLs which were set at initdb time, see
1990 * pg_init_privs).
1991 */
1993 }
1996 {
1997 /* Other system schemas don't get dumped */
1999 }
2001 {
2002 /*
2003 * The public schema is a strange beast that sits in a sort of
2004 * no-mans-land between being a system object and a user object.
2005 * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
2006 * a comment and an indication of ownership. If the owner is the
2007 * default, omit that superfluous DUMP_COMPONENT_DEFINITION. Before
2008 * v15, the default owner was BOOTSTRAP_SUPERUSERID.
2009 */
2015
2016 /*
2017 * Also, make like it has a comment even if it doesn't; this is so
2018 * that we'll emit a command to drop the comment, if appropriate.
2019 * (Without this, we'd not call dumpCommentExtended for it.)
2020 */
2022 }
2023 else
2025
2026 /*
2027 * In any case, a namespace can be excluded by an exclusion switch
2028 */
2031 nsinfo->dobj.catId.oid))
2033
2034 /*
2035 * If the schema belongs to an extension, allow extension membership to
2036 * override the dump decision for the schema itself. However, this does
2037 * not change dump_contains, so this won't change what we do with objects
2038 * within the schema. (If they belong to the extension, they'll get
2039 * suppressed by it, otherwise not.)
2040 */
2042}
2043
2044/*
2045 * selectDumpableTable: policy-setting subroutine
2046 * Mark a table as to be dumped or not
2047 */
2048static void
2050{
2052 return; /* extension membership overrides all else */
2053
2054 /*
2055 * If specific tables are being dumped, dump just those tables; else, dump
2056 * according to the parent namespace's dump flag.
2057 */
2060 tbinfo->dobj.catId.oid) ?
2062 else
2064
2065 /*
2066 * In any case, a table can be excluded by an exclusion switch
2067 */
2070 tbinfo->dobj.catId.oid))
2072}
2073
2074/*
2075 * selectDumpableType: policy-setting subroutine
2076 * Mark a type as to be dumped or not
2077 *
2078 * If it's a table's rowtype or an autogenerated array type, we also apply a
2079 * special type code to facilitate sorting into the desired order. (We don't
2080 * want to consider those to be ordinary types because that would bring tables
2081 * up into the datatype part of the dump order.) We still set the object's
2082 * dump flag; that's not going to cause the dummy type to be dumped, but we
2083 * need it so that casts involving such types will be dumped correctly -- see
2084 * dumpCast. This means the flag should be set the same as for the underlying
2085 * object (the table or base type).
2086 */
2087static void
2089{
2090 /* skip complex types, except for standalone composite types */
2093 {
2095
2099 else
2101 return;
2102 }
2103
2104 /* skip auto-generated array and multirange types */
2106 {
2108
2109 /*
2110 * Fall through to set the dump flag; we assume that the subsequent
2111 * rules will do the same thing as they would for the array's base
2112 * type or multirange's range type. (We cannot reliably look up the
2113 * base type here, since getTypes may not have processed it yet.)
2114 */
2115 }
2116
2118 return; /* extension membership overrides all else */
2119
2120 /* Dump based on if the contents of the namespace are being dumped */
2122}
2123
2124/*
2125 * selectDumpableDefaultACL: policy-setting subroutine
2126 * Mark a default ACL as to be dumped or not
2127 *
2128 * For per-schema default ACLs, dump if the schema is to be dumped.
2129 * Otherwise dump if we are dumping "everything". Note that dumpSchema
2130 * and aclsSkip are checked separately.
2131 */
2132static void
2134{
2135 /* Default ACLs can't be extension members */
2136
2138 /* default ACLs are considered part of the namespace */
2140 else
2143}
2144
2145/*
2146 * selectDumpableCast: policy-setting subroutine
2147 * Mark a cast as to be dumped or not
2148 *
2149 * Casts do not belong to any particular namespace (since they haven't got
2150 * names), nor do they have identifiable owners. To distinguish user-defined
2151 * casts from built-in ones, we must resort to checking whether the cast's
2152 * OID is in the range reserved for initdb.
2153 */
2154static void
2156{
2158 return; /* extension membership overrides all else */
2159
2160 /*
2161 * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
2162 * support ACLs currently.
2163 */
2166 else
2169}
2170
2171/*
2172 * selectDumpableProcLang: policy-setting subroutine
2173 * Mark a procedural language as to be dumped or not
2174 *
2175 * Procedural languages do not belong to any particular namespace. To
2176 * identify built-in languages, we must resort to checking whether the
2177 * language's OID is in the range reserved for initdb.
2178 */
2179static void
2181{
2183 return; /* extension membership overrides all else */
2184
2185 /*
2186 * Only include procedural languages when we are dumping everything.
2187 *
2188 * For from-initdb procedural languages, only include ACLs, as we do for
2189 * the pg_catalog namespace. We need this because procedural languages do
2190 * not live in any namespace.
2191 */
2194 else
2195 {
2198 else
2200 }
2201}
2202
2203/*
2204 * selectDumpableAccessMethod: policy-setting subroutine
2205 * Mark an access method as to be dumped or not
2206 *
2207 * Access methods do not belong to any particular namespace. To identify
2208 * built-in access methods, we must resort to checking whether the
2209 * method's OID is in the range reserved for initdb.
2210 */
2211static void
2213{
2215 return; /* extension membership overrides all else */
2216
2217 /*
2218 * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
2219 * they do not support ACLs currently.
2220 */
2223 else
2226}
2227
2228/*
2229 * selectDumpableExtension: policy-setting subroutine
2230 * Mark an extension as to be dumped or not
2231 *
2232 * Built-in extensions should be skipped except for checking ACLs, since we
2233 * assume those will already be installed in the target database. We identify
2234 * such extensions by their having OIDs in the range reserved for initdb.
2235 * We dump all user-added extensions by default. No extensions are dumped
2236 * if include_everything is false (i.e., a --schema or --table switch was
2237 * given), except if --extension specifies a list of extensions to dump.
2238 */
2239static void
2241{
2242 /*
2243 * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
2244 * change permissions on their member objects, if they wish to, and have
2245 * those changes preserved.
2246 */
2249 else
2250 {
2251 /* check if there is a list of extensions to dump */
2255 extinfo->dobj.catId.oid) ?
2257 else
2259 dopt->include_everything ?
2261
2262 /* check that the extension is not explicitly excluded */
2265 extinfo->dobj.catId.oid))
2267 }
2268}
2269
2270/*
2271 * selectDumpablePublicationObject: policy-setting subroutine
2272 * Mark a publication object as to be dumped or not
2273 *
2274 * A publication can have schemas and tables which have schemas, but those are
2275 * ignored in decision making, because publications are only dumped when we are
2276 * dumping everything.
2277 */
2278static void
2280{
2282 return; /* extension membership overrides all else */
2283
2286}
2287
2288/*
2289 * selectDumpableStatisticsObject: policy-setting subroutine
2290 * Mark an extended statistics object as to be dumped or not
2291 *
2292 * We dump an extended statistics object if the schema it's in and the table
2293 * it's for are being dumped. (This'll need more thought if statistics
2294 * objects ever support cross-table stats.)
2295 */
2296static void
2298{
2300 return; /* extension membership overrides all else */
2301
2306}
2307
2308/*
2309 * selectDumpableObject: policy-setting subroutine
2310 * Mark a generic dumpable object as to be dumped or not
2311 *
2312 * Use this only for object types without a special-case routine above.
2313 */
2314static void
2316{
2318 return; /* extension membership overrides all else */
2319
2320 /*
2321 * Default policy is to dump if parent namespace is dumpable, or for
2322 * non-namespace-associated items, dump if we're dumping "everything".
2323 */
2324 if (dobj->namespace)
2326 else
2329}
2330
2331/*
2332 * Dump a table's contents for loading using the COPY command
2333 * - this routine is called by the Archiver when it wants the table
2334 * to be dumped.
2335 */
2336static int
2338{
2343
2344 /*
2345 * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
2346 * which uses it already.
2347 */
2350 PGresult *res;
2351 int ret;
2354
2356 tbinfo->dobj.namespace->dobj.name, classname);
2357
2358 /*
2359 * Specify the column list explicitly so that we have no possibility of
2360 * retrieving data in the wrong column order. (The default column
2361 * ordering of COPY will not be what we want in certain corner cases
2362 * involving ADD COLUMN and inheritance.)
2363 */
2365
2366 /*
2367 * Use COPY (SELECT ...) TO when dumping a foreign table's data, when a
2368 * filter condition was specified, and when in binary upgrade mode and
2369 * dumping an old pg_largeobject_metadata defined WITH OIDS. For other
2370 * cases a simple COPY suffices.
2371 */
2375 {
2376 /* Temporary allows to access to foreign tables to dump data */
2379
2381 /* klugery to get rid of parens in column list */
2383 {
2386 }
2387 else
2389
2393 }
2394 else
2395 {
2398 column_list);
2399 }
2401 PQclear(res);
2403
2404 for (;;)
2405 {
2407
2408 if (ret < 0)
2409 break; /* done or error */
2410
2412 {
2415 }
2416
2417 /* ----------
2418 * THROTTLE:
2419 *
2420 * There was considerable discussion in late July, 2000 regarding
2421 * slowing down pg_dump when backing up large tables. Users with both
2422 * slow & fast (multi-processor) machines experienced performance
2423 * degradation when doing a backup.
2424 *
2425 * Initial attempts based on sleeping for a number of ms for each ms
2426 * of work were deemed too complex, then a simple 'sleep in each loop'
2427 * implementation was suggested. The latter failed because the loop
2428 * was too tight. Finally, the following was implemented:
2429 *
2430 * If throttle is non-zero, then
2431 * See how long since the last sleep.
2432 * Work out how long to sleep (based on ratio).
2433 * If sleep is more than 100ms, then
2434 * sleep
2435 * reset timer
2436 * EndIf
2437 * EndIf
2438 *
2439 * where the throttle value was the number of ms to sleep per ms of
2440 * work. The calculation was done in each loop.
2441 *
2442 * Most of the hard work is done in the backend, and this solution
2443 * still did not work particularly well: on slow machines, the ratio
2444 * was 50:1, and on medium paced machines, 1:1, and on fast
2445 * multi-processor machines, it had little or no effect, for reasons
2446 * that were unclear.
2447 *
2448 * Further discussion ensued, and the proposal was dropped.
2449 *
2450 * For those people who want this feature, it can be implemented using
2451 * gettimeofday in each loop, calculating the time since last sleep,
2452 * multiplying that by the sleep ratio, then if the result is more
2453 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
2454 * function to sleep for a subsecond period ie.
2455 *
2456 * select(0, NULL, NULL, NULL, &tvi);
2457 *
2458 * This will return after the interval specified in the structure tvi.
2459 * Finally, call gettimeofday again to save the 'last sleep time'.
2460 * ----------
2461 */
2462 }
2464
2465 if (ret == -2)
2466 {
2467 /* copy data transfer failed */
2468 pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
2471 exit_nicely(1);
2472 }
2473
2474 /* Check command status and return to normal libpq state */
2477 {
2481 exit_nicely(1);
2482 }
2483 PQclear(res);
2484
2485 /* Do this to ensure we've pumped libpq back to idle state */
2488 classname);
2489
2490 destroyPQExpBuffer(q);
2491
2492 /* Revert back the setting */
2495
2496 return 1;
2497}
2498
2499/*
2500 * Dump table data using INSERT commands.
2501 *
2502 * Caution: when we restore from an archive file direct to database, the
2503 * INSERT commands emitted by this function have to be parsed by
2504 * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
2505 * E'' strings, or dollar-quoted strings. So don't emit anything like that.
2506 */
2507static int
2509{
2515 char *attgenerated;
2516 PGresult *res;
2517 int nfields,
2518 i;
2521
2522 /* Temporary allows to access to foreign tables to dump data */
2525
2526 /*
2527 * If we're going to emit INSERTs with column names, the most efficient
2528 * way to deal with generated columns is to exclude them entirely. For
2529 * INSERTs without column names, we have to emit DEFAULT rather than the
2530 * actual column value --- but we can save a few cycles by fetching nulls
2531 * rather than the uninteresting-to-us value.
2532 */
2535 nfields = 0;
2537 {
2539 continue;
2541 continue;
2542 if (nfields > 0)
2546 else
2549 nfields++;
2550 }
2551 /* Servers before 9.4 will complain about zero-column SELECT */
2552 if (nfields == 0)
2558
2560
2561 while (1)
2562 {
2564 PGRES_TUPLES_OK);
2565
2566 /* cross-check field count, allowing for dummy NULL if any */
2568 !(nfields == 0 && PQnfields(res) == 1))
2570 tbinfo->dobj.name);
2571
2572 /*
2573 * First time through, we build as much of the INSERT statement as
2574 * possible in "insertStmt", which we can then just print for each
2575 * statement. If the table happens to have zero dumpable columns then
2576 * this will be a complete statement, otherwise it will end in
2577 * "VALUES" and be ready to have the row's column values printed.
2578 */
2580 {
2582
2584
2585 /*
2586 * When load-via-partition-root is set or forced, get the root
2587 * table name for the partition table, so that we can reload data
2588 * through the root table.
2589 */
2591 (dopt->load_via_partition_root ||
2594 else
2596
2599
2600 /* corner case for zero-column table */
2601 if (nfields == 0)
2602 {
2604 }
2605 else
2606 {
2607 /* append the list of column names if required */
2609 {
2611 for (int field = 0; field < nfields; field++)
2612 {
2613 if (field > 0)
2617 }
2619 }
2620
2623
2625 }
2626 }
2627
2629 {
2630 /* Write the INSERT if not in the middle of a multi-row INSERT. */
2633
2634 /*
2635 * If it is zero-column table then we've already written the
2636 * complete statement, which will mean we've disobeyed
2637 * --rows-per-insert when it's set greater than 1. We do support
2638 * a way to make this multi-row with: SELECT UNION ALL SELECT
2639 * UNION ALL ... but that's non-standard so we should avoid it
2640 * given that using INSERTs is mostly only ever needed for
2641 * cross-database exports.
2642 */
2643 if (nfields == 0)
2644 continue;
2645
2646 /* Emit a row heading */
2651 else
2653
2654 for (int field = 0; field < nfields; field++)
2655 {
2656 if (field > 0)
2658 if (attgenerated[field])
2659 {
2661 continue;
2662 }
2664 {
2666 continue;
2667 }
2668
2669 /* XXX This code is partially duplicated in ruleutils.c */
2671 {
2679 {
2680 /*
2681 * These types are printed without quotes unless
2682 * they contain values that aren't accepted by the
2683 * scanner unquoted (e.g., 'NaN'). Note that
2684 * strtod() and friends might accept NaN, so we
2685 * can't use that to test.
2686 *
2687 * In reality we only need to defend against
2688 * infinity and NaN, so we need not get too crazy
2689 * about pattern matching here.
2690 */
2692
2695 else
2697 }
2698 break;
2699
2703 PQgetvalue(res, tuple, field));
2704 break;
2705
2709 else
2711 break;
2712
2713 default:
2714 /* All other types are printed as string literals. */
2715 resetPQExpBuffer(q);
2716 appendStringLiteralAH(q,
2717 PQgetvalue(res, tuple, field),
2718 fout);
2720 break;
2721 }
2722 }
2723
2724 /* Terminate the row ... */
2726
2727 /* ... and the statement, if the target no. of rows is reached */
2729 {
2732 else
2734 /* Reset the row counter */
2735 rows_this_statement = 0;
2736 }
2737 }
2738
2740 {
2741 PQclear(res);
2742 break;
2743 }
2744 PQclear(res);
2745 }
2746
2747 /* Terminate any statements that didn't make the row count. */
2749 {
2752 else
2754 }
2755
2757
2759
2760 destroyPQExpBuffer(q);
2763 pg_free(attgenerated);
2764
2765 /* Revert back the setting */
2768
2769 return 1;
2770}
2771
2772/*
2773 * getRootTableInfo:
2774 * get the root TableInfo for the given partition table.
2775 */
2778{
2780
2783
2786 {
2789 }
2790
2792}
2793
2794/*
2795 * forcePartitionRootLoad
2796 * Check if we must force load_via_partition_root for this partition.
2797 *
2798 * This is required if any level of ancestral partitioned table has an
2799 * unsafe partitioning scheme.
2800 */
2801static bool
2803{
2805
2808
2811 return true;
2813 {
2817 return true;
2818 }
2819
2820 return false;
2821}
2822
2823/*
2824 * dumpTableData -
2825 * dump the contents of a single table
2826 *
2827 * Actually, this just makes an ArchiveEntry for the table contents.
2828 */
2829static void
2831{
2836 DataDumperPtr dumpFn;
2838 char *copyStmt;
2840
2841 /* We had better have loaded per-column details about this table */
2843
2844 /*
2845 * When load-via-partition-root is set or forced, get the root table name
2846 * for the partition table, so that we can reload data through the root
2847 * table. Then construct a comment to be inserted into the TOC entry's
2848 * defn field, so that such cases can be identified reliably.
2849 */
2851 (dopt->load_via_partition_root ||
2853 {
2856
2861 sanitized);
2864 }
2865 else
2867
2869 {
2870 /* Dump/restore using COPY */
2871 dumpFn = dumpTableData_copy;
2872 /* must use 2 steps here 'cause fmtId is nonreentrant */
2874 copyFrom);
2877 copyStmt = copyBuf->data;
2878 }
2879 else
2880 {
2881 /* Restore using INSERT */
2882 dumpFn = dumpTableData_insert;
2883 copyStmt = NULL;
2884 }
2885
2886 /*
2887 * Note: although the TableDataInfo is a full DumpableObject, we treat its
2888 * dependency on its table as "special" and pass it to ArchiveEntry now.
2889 * See comments for BuildArchiveDependencies.
2890 */
2892 {
2893 TocEntry *te;
2894
2897 .namespace = tbinfo->dobj.namespace->dobj.name,
2898 .owner = tbinfo->rolname,
2899 .description = "TABLE DATA",
2900 .section = SECTION_DATA,
2901 .createStmt = tdDefn,
2902 .copyStmt = copyStmt,
2903 .deps = &(tbinfo->dobj.dumpId),
2904 .nDeps = 1,
2905 .dumpFn = dumpFn,
2906 .dumpArg = tdinfo));
2907
2908 /*
2909 * Set the TocEntry's dataLength in case we are doing a parallel dump
2910 * and want to order dump jobs by table size. We choose to measure
2911 * dataLength in table pages (including TOAST pages) during dump, so
2912 * no scaling is needed.
2913 *
2914 * However, relpages is declared as "integer" in pg_class, and hence
2915 * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
2916 * Cast so that we get the right interpretation of table sizes
2917 * exceeding INT_MAX pages.
2918 */
2921
2922 /*
2923 * If pgoff_t is only 32 bits wide, the above refinement is useless,
2924 * and instead we'd better worry about integer overflow. Clamp to
2925 * INT_MAX if the correct result exceeds that.
2926 */
2927 if (sizeof(te->dataLength) == 4 &&
2929 te->dataLength < 0))
2930 te->dataLength = INT_MAX;
2931 }
2932
2935}
2936
2937/*
2938 * refreshMatViewData -
2939 * load or refresh the contents of a single materialized view
2940 *
2941 * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
2942 * statement.
2943 */
2944static void
2946{
2948 PQExpBuffer q;
2949
2950 /* If the materialized view is not flagged as populated, skip this. */
2952 return;
2953
2954 q = createPQExpBuffer();
2955
2958
2964 .namespace = tbinfo->dobj.namespace->dobj.name,
2965 .owner = tbinfo->rolname,
2966 .description = "MATERIALIZED VIEW DATA",
2967 .section = SECTION_POST_DATA,
2968 .createStmt = q->data,
2969 .deps = tdinfo->dobj.dependencies,
2970 .nDeps = tdinfo->dobj.nDeps));
2971
2972 destroyPQExpBuffer(q);
2973}
2974
2975/*
2976 * getTableData -
2977 * set up dumpable objects representing the contents of tables
2978 */
2979static void
2981{
2983
2985 {
2987 (!relkind || tblinfo[i].relkind == relkind))
2989 }
2990}
2991
2992/*
2993 * Make a dumpable object for the data of this specific table
2994 *
2995 * Note: we make a TableDataInfo if and only if we are going to dump the
2996 * table data; the "dump" field in such objects isn't very interesting.
2997 */
2998static void
3000{
3002
3003 /*
3004 * Nothing to do if we already decided to dump the table. This will
3005 * happen for "config" tables.
3006 */
3008 return;
3009
3010 /* Skip property graphs (no data to dump) */
3012 return;
3013 /* Skip VIEWs (no data to dump) */
3015 return;
3016 /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
3020 tbinfo->foreign_server)))
3021 return;
3022 /* Skip partitioned tables (data in partitions) */
3024 return;
3025
3026 /* Don't dump data in unlogged tables, if so requested */
3028 dopt->no_unlogged_table_data)
3029 return;
3030
3031 /* Check that the data is not explicitly excluded */
3033 tbinfo->dobj.catId.oid))
3034 return;
3035
3036 /* OK, let's dump it */
3038
3043 else
3045
3046 /*
3047 * Note: use tableoid 0 so that this object won't be mistaken for
3048 * something that pg_depend entries apply to.
3049 */
3050 tdinfo->dobj.catId.tableoid = 0;
3058
3059 /* A TableDataInfo contains data, of course */
3061
3063
3064 /*
3065 * Materialized view statistics must be restored after the data, because
3066 * REFRESH MATERIALIZED VIEW replaces the storage and resets the stats.
3067 *
3068 * The dependency is added here because the statistics objects are created
3069 * first.
3070 */
3072 {
3075 }
3076
3077 /* Make sure that we'll collect per-column info for this table. */
3079}
3080
3081/*
3082 * The refresh for a materialized view must be dependent on the refresh for
3083 * any materialized view that this one is dependent on.
3084 *
3085 * This must be called after all the objects are created, but before they are
3086 * sorted.
3087 */
3088static void
3090{
3091 PQExpBuffer query;
3092 PGresult *res;
3093 int ntups,
3094 i;
3096 i_objid,
3097 i_refobjid;
3098
3099 query = createPQExpBuffer();
3100
3102 "( "
3103 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3104 "FROM pg_depend d1 "
3105 "JOIN pg_class c1 ON c1.oid = d1.objid "
3107 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3108 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3109 "AND d2.objid = r1.oid "
3110 "AND d2.refobjid <> d1.objid "
3111 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3114 "WHERE d1.classid = 'pg_class'::regclass "
3115 "UNION "
3116 "SELECT w.objid, d3.refobjid, c3.relkind "
3117 "FROM w "
3118 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3119 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3120 "AND d3.objid = r3.oid "
3121 "AND d3.refobjid <> w.refobjid "
3122 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3125 ") "
3126 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3127 "FROM w "
3129
3131
3132 ntups = PQntuples(res);
3133
3137
3139 {
3140 CatalogId objId;
3142 DumpableObject *dobj;
3146
3151
3152 dobj = findObjectByCatalogId(objId);
3154 continue;
3155
3161 continue;
3163
3166 continue;
3167
3173 continue;
3175
3177
3180 }
3181
3182 PQclear(res);
3183
3184 destroyPQExpBuffer(query);
3185}
3186
3187/*
3188 * getTableDataFKConstraints -
3189 * add dump-order dependencies reflecting foreign key constraints
3190 *
3191 * This code is executed only in a data-only dump --- in schema+data dumps
3192 * we handle foreign key issues by not creating the FK constraints until
3193 * after the data is loaded. In a data-only dump, however, we want to
3194 * order the table data objects in such a way that a table's referenced
3195 * tables are restored first. (In the presence of circular references or
3196 * self-references this may be impossible; we'll detect and complain about
3197 * that during the dependency sorting step.)
3198 */
3199static void
3201{
3205
3206 /* Search through all the dumpable objects for FK constraints */
3209 {
3211 {
3214
3215 /* Not interesting unless both tables are to be dumped */
3218 continue;
3222 continue;
3223
3224 /*
3225 * Okay, make referencing table's TABLE_DATA object depend on the
3226 * referenced table's TABLE_DATA object.
3227 */
3229 ftable->dataObj->dobj.dumpId);
3230 }
3231 }
3233}
3234
3235
3236/*
3237 * dumpDatabase:
3238 * dump the database definition
3239 */
3240static void
3242{
3249 PGresult *res;
3251 i_oid,
3252 i_datname,
3253 i_datdba,
3254 i_encoding,
3255 i_datlocprovider,
3256 i_collate,
3257 i_ctype,
3258 i_datlocale,
3259 i_daticurules,
3260 i_frozenxid,
3261 i_minmxid,
3262 i_datacl,
3263 i_acldefault,
3264 i_datistemplate,
3265 i_datconnlimit,
3266 i_datcollversion,
3267 i_tablespace;
3272 *dba,
3273 *encoding,
3274 *datlocprovider,
3275 *collate,
3276 *ctype,
3277 *locale,
3278 *icurules,
3279 *datistemplate,
3280 *datconnlimit,
3281 *tablespace;
3282 uint32 frozenxid,
3283 minmxid;
3285
3287
3288 /*
3289 * Fetch the database-level properties for this database.
3290 */
3292 "datdba, "
3293 "pg_encoding_to_char(encoding) AS encoding, "
3294 "datcollate, datctype, datfrozenxid, "
3295 "datacl, acldefault('d', datdba) AS acldefault, "
3296 "datistemplate, datconnlimit, ");
3302 else
3303 appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
3306 else
3309 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
3310 "shobj_description(oid, 'pg_database') AS description "
3311 "FROM pg_database "
3312 "WHERE datname = current_database()");
3313
3315
3334
3345 else
3346 locale = NULL;
3349 else
3358
3360
3361 /*
3362 * Prepare the CREATE DATABASE command. We must specify OID (if we want
3363 * to preserve that), as well as the encoding, locale, and tablespace
3364 * since those can't be altered later. Other DB properties are left to
3365 * the DATABASE PROPERTIES entry, so that they can be applied after
3366 * reconnecting to the target DB.
3367 *
3368 * For binary upgrade, we use the FILE_COPY strategy because testing has
3369 * shown it to be faster. When the server is in binary upgrade mode, it
3370 * will also skip the checkpoints this strategy ordinarily performs.
3371 */
3373 {
3375 "CREATE DATABASE %s WITH TEMPLATE = template0 "
3376 "OID = %u STRATEGY = FILE_COPY",
3378 }
3379 else
3380 {
3382 qdatname);
3383 }
3385 {
3388 }
3389
3397 else
3399 datlocprovider);
3400
3402 {
3405 }
3406 else
3407 {
3409 {
3412 }
3414 {
3417 }
3418 }
3419 if (locale)
3420 {
3423 else
3425
3427 }
3428
3430 {
3433 }
3434
3435 /*
3436 * For binary upgrade, carry over the collation version. For normal
3437 * dump/restore, omit the version, so that it is computed upon restore.
3438 */
3440 {
3442 {
3446 fout);
3447 }
3448 }
3449
3450 /*
3451 * Note: looking at dopt->outputNoTablespaces here is completely the wrong
3452 * thing; the decision whether to specify a tablespace should be left till
3453 * pg_restore, so that pg_restore --no-tablespaces applies. Ideally we'd
3454 * label the DATABASE entry with the tablespace and let the normal
3455 * tablespace selection logic work ... but CREATE DATABASE doesn't pay
3456 * attention to default_tablespace, so that won't work.
3457 */
3459 !dopt->outputNoTablespaces)
3463
3465 qdatname);
3466
3468
3473 .owner = dba,
3475 .section = SECTION_PRE_DATA,
3477 .dropStmt = delQry->data));
3478
3479 /* Compute correct tag for archive entry */
3481
3482 /* Dump DB comment if any */
3483 {
3484 /*
3485 * 8.2 and up keep comments on shared objects in a shared table, so we
3486 * cannot use the dumpComment() code used for other database objects.
3487 * Be careful that the ArchiveEntry parameters match that function.
3488 */
3490
3492 {
3494
3495 /*
3496 * Generates warning when loaded into a differently-named
3497 * database.
3498 */
3502
3505 .owner = dba,
3506 .description = "COMMENT",
3507 .section = SECTION_NONE,
3508 .createStmt = dbQry->data,
3509 .deps = &dbDumpId,
3510 .nDeps = 1));
3511 }
3512 }
3513
3514 /* Dump DB security label, if enabled */
3516 {
3519
3521
3529 .owner = dba,
3530 .description = "SECURITY LABEL",
3531 .section = SECTION_NONE,
3532 .createStmt = seclabelQry->data,
3533 .deps = &dbDumpId,
3534 .nDeps = 1));
3537 }
3538
3539 /*
3540 * Dump ACL if any. Note that we do not support initial privileges
3541 * (pg_init_privs) on databases.
3542 */
3543 dbdacl.privtype = 0;
3545
3549
3550 /*
3551 * Now construct a DATABASE PROPERTIES archive entry to restore any
3552 * non-default database-level properties. (The reason this must be
3553 * separate is that we cannot put any additional commands into the TOC
3554 * entry that has CREATE DATABASE. pg_restore would execute such a group
3555 * in an implicit transaction block, and the backend won't allow CREATE
3556 * DATABASE in that context.)
3557 */
3560
3564
3566 {
3568 qdatname);
3569
3570 /*
3571 * The backend won't accept DROP DATABASE on a template database. We
3572 * can deal with that by removing the template marking before the DROP
3573 * gets issued. We'd prefer to use ALTER DATABASE IF EXISTS here, but
3574 * since no such command is currently supported, fake it with a direct
3575 * UPDATE on pg_database.
3576 */
3578 "SET datistemplate = false WHERE datname = ");
3581 }
3582
3583 /*
3584 * We do not restore pg_database.dathasloginevt because it is set
3585 * automatically on login event trigger creation.
3586 */
3587
3588 /* Add database-specific SET options */
3590
3591 /*
3592 * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
3593 * entry, too, for lack of a better place.
3594 */
3596 {
3599 "SET datfrozenxid = '%u', datminmxid = '%u'\n"
3600 "WHERE datname = ",
3601 frozenxid, minmxid);
3604 }
3605
3609 .owner = dba,
3611 .section = SECTION_PRE_DATA,
3613 .dropStmt = delQry->data,
3614 .deps = &dbDumpId));
3615
3616 /*
3617 * pg_largeobject comes from the old system intact, so set its
3618 * relfrozenxids, relminmxids and relfilenode.
3619 *
3620 * pg_largeobject_metadata also comes from the old system intact for
3621 * upgrades from v16 and newer, so set its relfrozenxids, relminmxids, and
3622 * relfilenode, too. pg_upgrade can't copy/link the files from older
3623 * versions because aclitem (needed by pg_largeobject_metadata.lomacl)
3624 * changed its storage format in v16.
3625 */
3627 {
3635 ii_relfilenode,
3636 ii_oid,
3637 ii_relminmxid;
3638
3640 "FROM pg_catalog.pg_class\n"
3641 "WHERE oid IN (%u, %u, %u, %u);\n",
3644
3646
3651
3652 appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
3653 appendPQExpBufferStr(lomHorizonQry, "\n-- For binary upgrade, set pg_largeobject_metadata relfrozenxid and relminmxid\n");
3654 appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
3655 appendPQExpBufferStr(lomOutQry, "\n-- For binary upgrade, preserve pg_largeobject_metadata and index relfilenodes\n");
3657 {
3658 Oid oid;
3659 RelFileNumber relfilenumber;
3662
3665
3667 oid == LargeObjectLOidPNIndexId)
3668 {
3671 }
3672 else
3673 {
3676 }
3677
3679 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
3680 "WHERE oid = %u;\n",
3684
3686 oid == LargeObjectMetadataRelationId)
3688 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
3689 relfilenumber);
3691 oid == LargeObjectMetadataOidIndexId)
3693 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
3694 relfilenumber);
3695 }
3696
3698 "TRUNCATE pg_catalog.pg_largeobject;\n");
3700 "TRUNCATE pg_catalog.pg_largeobject_metadata;\n");
3701
3704
3708 .section = SECTION_PRE_DATA,
3709 .createStmt = loOutQry->data));
3710
3715 .section = SECTION_PRE_DATA,
3716 .createStmt = lomOutQry->data));
3717
3719
3725 }
3726
3727 PQclear(res);
3728
3734}
3735
3736/*
3737 * Collect any database-specific or role-and-database-specific SET options
3738 * for this database, and append them to outbuf.
3739 */
3740static void
3743{
3746 PGresult *res;
3747
3748 /* First collect database-specific options */
3750 "WHERE setrole = 0 AND setdatabase = '%u'::oid",
3751 dboid);
3752
3754
3758 outbuf);
3759
3760 PQclear(res);
3761
3762 /* Now look for role-and-database-specific options */
3764 "FROM pg_db_role_setting s, pg_roles r "
3765 "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
3766 dboid);
3767
3769
3774 outbuf);
3775
3776 PQclear(res);
3777
3779}
3780
3781/*
3782 * dumpEncoding: put the correct encoding into the archive
3783 */
3784static void
3786{
3789
3791
3795
3799 .section = SECTION_PRE_DATA,
3800 .createStmt = qry->data));
3801
3802 destroyPQExpBuffer(qry);
3803}
3804
3805
3806/*
3807 * dumpStdStrings: put the correct escape string behavior into the archive
3808 */
3809static void
3811{
3814
3816 stdstrings);
3817
3819 stdstrings);
3820
3824 .section = SECTION_PRE_DATA,
3825 .createStmt = qry->data));
3826
3827 destroyPQExpBuffer(qry);
3828}
3829
3830/*
3831 * dumpSearchPath: record the active search_path in the archive
3832 */
3833static void
3835{
3838 PGresult *res;
3842
3843 /*
3844 * We use the result of current_schemas(), not the search_path GUC,
3845 * because that might contain wildcards such as "$user", which won't
3846 * necessarily have the same value during restore. Also, this way avoids
3847 * listing schemas that may appear in search_path but not actually exist,
3848 * which seems like a prudent exclusion.
3849 */
3850 res = ExecuteSqlQueryForSingleRow(AH,
3851 "SELECT pg_catalog.current_schemas(false)");
3852
3855
3856 /*
3857 * We use set_config(), not a simple "SET search_path" command, because
3858 * the latter has less-clean behavior if the search path is empty. While
3859 * that's likely to get fixed at some point, it seems like a good idea to
3860 * be as backwards-compatible as possible in what we put into archives.
3861 */
3863 {
3867 }
3868
3872
3874
3878 .section = SECTION_PRE_DATA,
3879 .createStmt = qry->data));
3880
3881 /* Also save it in AH->searchpath, in case we're doing plain text dump */
3883
3885 PQclear(res);
3886 destroyPQExpBuffer(qry);
3887 destroyPQExpBuffer(path);
3888}
3889
3890
3891/*
3892 * getLOs:
3893 * Collect schema-level data about large objects
3894 */
3895static void
3897{
3900 PGresult *res;
3901 int ntups;
3903 int n;
3908
3910
3911 /*
3912 * Fetch LO OIDs and owner/ACL data. Order the data so that all the blobs
3913 * with the same owner/ACL appear together.
3914 */
3916 "SELECT oid, lomowner, lomacl, "
3917 "acldefault('L', lomowner) AS acldefault "
3918 "FROM pg_largeobject_metadata ");
3919
3920 /*
3921 * For binary upgrades, we transfer pg_largeobject_metadata via COPY or by
3922 * copying/linking its files from the old cluster. On such upgrades, we
3923 * only need to consider large objects that have comments or security
3924 * labels, since we still restore those objects via COMMENT/SECURITY LABEL
3925 * commands.
3926 */
3929 "WHERE oid IN "
3930 "(SELECT objoid FROM pg_description "
3932 "UNION SELECT objoid FROM pg_seclabel "
3934
3936 "ORDER BY lomowner, lomacl::pg_catalog.text, oid");
3937
3939
3944
3945 ntups = PQntuples(res);
3946
3947 /*
3948 * Group the blobs into suitably-sized groups that have the same owner and
3949 * ACL setting, and build a metadata and a data DumpableObject for each
3950 * group. (If we supported initprivs for blobs, we'd have to insist that
3951 * groups also share initprivs settings, since the DumpableObject only has
3952 * room for one.) i is the index of the first tuple in the current group,
3953 * and n is the number of tuples we include in the group.
3954 */
3956 {
3963
3964 /* Scan to find first tuple not to be included in group */
3965 n = 1;
3967 {
3970 break;
3971 n++;
3972 }
3973
3974 /* Build the metadata DumpableObject */
3976
3981
3982 if (n > 1)
3985 else
3990 loinfo->dacl.privtype = 0;
3993 loinfo->numlos = n;
3995 /* Collect OIDs of the remaining blobs in this group */
3996 for (int k = 1; k < n; k++)
3997 {
3999
4001
4002 /* Make sure we can look up loinfo by any of the blobs' OIDs */
4006 }
4007
4008 /* LOs have data */
4010
4011 /* Mark whether LO group has a non-empty ACL */
4014
4015 /*
4016 * In binary upgrade mode, pg_largeobject and pg_largeobject_metadata
4017 * are transferred via COPY or by copying/linking the files from the
4018 * old cluster. Thus, we do not need to dump LO data, definitions, or
4019 * ACLs.
4020 */
4023
4024 /*
4025 * Create a "BLOBS" data item for the group, too. This is just a
4026 * placeholder for sorting; it carries no data now.
4027 */
4034 /* Set up explicit dependency from data to metadata */
4038 }
4039
4040 PQclear(res);
4042}
4043
4044/*
4045 * dumpLO
4046 *
4047 * dump the definition (metadata) of the given large object group
4048 */
4049static void
4051{
4053
4054 /*
4055 * The "definition" is just a newline-separated list of OIDs. We need to
4056 * put something into the dropStmt too, but it can just be a comment.
4057 */
4060
4064 .owner = loinfo->rolname,
4065 .description = "BLOB METADATA",
4066 .section = SECTION_DATA,
4067 .createStmt = cquery->data,
4068 .dropStmt = "-- dummy"));
4069
4070 /*
4071 * Dump per-blob comments and seclabels if any. We assume these are rare
4072 * enough that it's okay to generate retail TOC entries for them.
4073 */
4075 DUMP_COMPONENT_SECLABEL))
4076 {
4078 {
4079 CatalogId catId;
4081
4082 /* Build identifying info for this blob */
4086
4090 catId, 0, loinfo->dobj.dumpId);
4091
4095 catId, 0, loinfo->dobj.dumpId);
4096 }
4097 }
4098
4099 /*
4100 * Dump the ACLs if any (remember that all blobs in the group will have
4101 * the same ACL). If there's just one blob, dump a simple ACL entry; if
4102 * there's more, make a "LARGE OBJECTS" entry that really contains only
4103 * the ACL for the first blob. _printTocEntry() will be cued by the tag
4104 * string to emit a mutated version for each blob.
4105 */
4107 {
4109
4110 /* Build identifying info for the first blob */
4112
4114 {
4116
4119
4123 }
4124 else
4125 {
4129 }
4130 }
4131
4133}
4134
4135/*
4136 * dumpLOs:
4137 * dump the data contents of the large objects in the given group
4138 */
4139static int
4141{
4145
4147
4149 {
4151 int loFd;
4152 int cnt;
4153
4154 /* Open the LO */
4156 if (loFd == -1)
4159
4161
4162 /* Now read it in chunks, sending data to archive */
4163 do
4164 {
4166 if (cnt < 0)
4169
4171 } while (cnt > 0);
4172
4174
4176 }
4177
4178 return 1;
4179}
4180
4181/*
4182 * getPolicies
4183 * get information about all RLS policies on dumpable tables.
4184 */
4185void
4187{
4189 PQExpBuffer query;
4191 PGresult *res;
4203 j,
4204 ntups;
4205
4206 /* Skip if --no-policies was specified */
4208 return;
4209
4210 query = createPQExpBuffer();
4212
4213 /*
4214 * Identify tables of interest, and check which ones have RLS enabled.
4215 */
4218 {
4220
4221 /* Ignore row security on tables not to be dumped */
4223 continue;
4224
4225 /* It can't have RLS or policies if it's not a table */
4228 continue;
4229
4230 /* Add it to the list of table OIDs to be probed below */
4234
4235 /* Is RLS enabled? (That's separate from whether it has policies) */
4237 {
4239
4240 /*
4241 * We represent RLS being enabled on a table by creating a
4242 * PolicyInfo object with null polname.
4243 *
4244 * Note: use tableoid 0 so that this object won't be mistaken for
4245 * something that pg_depend entries apply to.
4246 */
4249 polinfo->dobj.catId.tableoid = 0;
4257 polinfo->polpermissive = 0;
4261 }
4262 }
4264
4265 /*
4266 * Now, read all RLS policies belonging to the tables of interest, and
4267 * create PolicyInfo objects for them. (Note that we must filter the
4268 * results server-side not locally, because we dare not apply pg_get_expr
4269 * to tables we don't have lock on.)
4270 */
4272
4273 printfPQExpBuffer(query,
4274 "SELECT pol.oid, pol.tableoid, pol.polrelid, pol.polname, pol.polcmd, ");
4276 appendPQExpBuffer(query,
4277 "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
4278 " 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, "
4279 "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
4280 "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
4281 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
4282 "JOIN pg_catalog.pg_policy pol ON (src.tbloid = pol.polrelid)",
4283 tbloids->data);
4284
4286
4287 ntups = PQntuples(res);
4288 if (ntups > 0)
4289 {
4299
4301
4303 {
4306
4308
4318
4321
4324 else
4326
4329 else
4331
4334 else
4337 }
4338 }
4339
4340 PQclear(res);
4341
4342 destroyPQExpBuffer(query);
4344}
4345
4346/*
4347 * dumpPolicy
4348 * dump the definition of the given policy
4349 */
4350static void
4352{
4355 PQExpBuffer query;
4359 const char *cmd;
4360 char *tag;
4361
4362 /* Do nothing if not dumping schema */
4364 return;
4365
4366 /*
4367 * If polname is NULL, then this record is just indicating that ROW LEVEL
4368 * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
4369 * ROW LEVEL SECURITY.
4370 */
4372 {
4373 query = createPQExpBuffer();
4374
4377
4378 /*
4379 * We must emit the ROW SECURITY object's dependency on its table
4380 * explicitly, because it will not match anything in pg_depend (unlike
4381 * the case for other PolicyInfo objects).
4382 */
4386 .namespace = polinfo->dobj.namespace->dobj.name,
4387 .owner = tbinfo->rolname,
4388 .description = "ROW SECURITY",
4389 .section = SECTION_POST_DATA,
4390 .createStmt = query->data,
4391 .deps = &(tbinfo->dobj.dumpId),
4392 .nDeps = 1));
4393
4394 destroyPQExpBuffer(query);
4395 return;
4396 }
4397
4399 cmd = "";
4401 cmd = " FOR SELECT";
4403 cmd = " FOR INSERT";
4405 cmd = " FOR UPDATE";
4407 cmd = " FOR DELETE";
4408 else
4410 polinfo->polcmd);
4411
4412 query = createPQExpBuffer();
4415
4417
4419
4422
4425
4428
4431
4433
4436
4439
4441
4444 ARCHIVE_OPTS(.tag = tag,
4446 .owner = tbinfo->rolname,
4447 .description = "POLICY",
4448 .section = SECTION_POST_DATA,
4449 .createStmt = query->data,
4450 .dropStmt = delqry->data));
4451
4456
4457 pfree(tag);
4458 destroyPQExpBuffer(query);
4462}
4463
4464/*
4465 * getPublications
4466 * get information about publications
4467 */
4468void
4470{
4472 PQExpBuffer query;
4473 PGresult *res;
4488 ntups;
4489
4491 return;
4492
4493 query = createPQExpBuffer();
4494
4495 /* Get the publications. */
4497 "p.pubowner, p.puballtables, p.pubinsert, "
4498 "p.pubupdate, p.pubdelete, ");
4499
4502 else
4504
4507 else
4509
4512 else
4514
4517 else
4519
4521
4523
4524 ntups = PQntuples(res);
4525
4526 if (ntups == 0)
4528
4541
4543
4545 {
4570 {
4572 };
4573
4574 /* Decide whether we want to dump it */
4576
4577 /*
4578 * Get the list of tables for publications specified in the EXCEPT
4579 * TABLE clause.
4580 *
4581 * Although individual table entries in EXCEPT list could be stored in
4582 * PublicationRelInfo, dumpPublicationTable cannot be used to emit
4583 * them, because there is no ALTER PUBLICATION ... ADD command to add
4584 * individual table entries to the EXCEPT list.
4585 *
4586 * Therefore, the approach is to dump the complete EXCEPT list in a
4587 * single CREATE PUBLICATION statement. PublicationInfo is used to
4588 * collect this information, which is then emitted by
4589 * dumpPublication().
4590 */
4592 {
4595
4596 resetPQExpBuffer(query);
4597 appendPQExpBuffer(query,
4598 "SELECT prrelid\n"
4599 "FROM pg_catalog.pg_publication_rel\n"
4600 "WHERE prpubid = %u AND prexcept",
4602
4604
4606
4608 {
4611
4613
4615
4618 }
4619
4621 }
4622 }
4623
4624cleanup:
4625 PQclear(res);
4626
4627 destroyPQExpBuffer(query);
4628}
4629
4630/*
4631 * dumpPublication
4632 * dump the definition of the given publication
4633 */
4634static void
4636{
4639 PQExpBuffer query;
4641 bool first = true;
4642
4643 /* Do nothing if not dumping schema */
4645 return;
4646
4648 query = createPQExpBuffer();
4649
4651
4653 qpubname);
4654
4656 qpubname);
4657
4659 {
4661
4663
4664 /* Include EXCEPT (TABLE) clause if there are except_tables. */
4666 {
4668
4671 else
4674 }
4677
4680 }
4683
4686 {
4688 first = false;
4689 }
4690
4692 {
4693 if (!first)
4695
4697 first = false;
4698 }
4699
4701 {
4702 if (!first)
4704
4706 first = false;
4707 }
4708
4710 {
4711 if (!first)
4713
4715 first = false;
4716 }
4717
4719
4722
4725
4727
4731 .owner = pubinfo->rolname,
4732 .description = "PUBLICATION",
4733 .section = SECTION_POST_DATA,
4734 .createStmt = query->data,
4735 .dropStmt = delq->data));
4736
4741
4746
4748 destroyPQExpBuffer(query);
4750}
4751
4752/*
4753 * getPublicationNamespaces
4754 * get information about publication membership for dumpable schemas.
4755 */
4756void
4758{
4759 PQExpBuffer query;
4760 PGresult *res;
4768 j,
4769 ntups;
4770
4772 return;
4773
4774 query = createPQExpBuffer();
4775
4776 /* Collect all publication membership info. */
4777 appendPQExpBufferStr(query,
4778 "SELECT tableoid, oid, pnpubid, pnnspid "
4779 "FROM pg_catalog.pg_publication_namespace");
4781
4782 ntups = PQntuples(res);
4783
4788
4789 /* this allocation may be more than we need */
4791 j = 0;
4792
4794 {
4799
4800 /*
4801 * Ignore any entries for which we aren't interested in either the
4802 * publication or the rel.
4803 */
4806 continue;
4809 continue;
4810
4811 /* OK, make a DumpableObject for this relationship */
4821
4822 /* Decide whether we want to dump it */
4824
4825 j++;
4826 }
4827
4828 PQclear(res);
4829 destroyPQExpBuffer(query);
4830}
4831
4832/*
4833 * getPublicationTables
4834 * get information about publication membership for dumpable tables.
4835 */
4836void
4838{
4839 PQExpBuffer query;
4840 PGresult *res;
4850 j,
4851 ntups;
4852
4854 return;
4855
4856 query = createPQExpBuffer();
4857
4858 /* Collect all publication membership info. */
4860 {
4861 appendPQExpBufferStr(query,
4862 "SELECT tableoid, oid, prpubid, prrelid, "
4863 "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
4864 "(CASE\n"
4865 " WHEN pr.prattrs IS NOT NULL THEN\n"
4866 " (SELECT array_agg(attname)\n"
4867 " FROM\n"
4868 " pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
4869 " pg_catalog.pg_attribute\n"
4870 " WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
4871 " ELSE NULL END) prattrs "
4872 "FROM pg_catalog.pg_publication_rel pr");
4875 }
4876 else
4877 appendPQExpBufferStr(query,
4878 "SELECT tableoid, oid, prpubid, prrelid, "
4879 "NULL AS prrelqual, NULL AS prattrs "
4880 "FROM pg_catalog.pg_publication_rel");
4882
4883 ntups = PQntuples(res);
4884
4891
4892 /* this allocation may be more than we need */
4894 j = 0;
4895
4897 {
4902
4903 /*
4904 * Ignore any entries for which we aren't interested in either the
4905 * publication or the rel.
4906 */
4909 continue;
4912 continue;
4913
4914 /* OK, make a DumpableObject for this relationship */
4926 else
4928
4930 {
4931 char **attnames;
4934
4936 &attnames, &nattnames))
4940 {
4941 if (k > 0)
4943
4945 }
4948 free(attnames);
4949 }
4950 else
4952
4953 /* Decide whether we want to dump it */
4955
4956 j++;
4957 }
4958
4959 PQclear(res);
4960 destroyPQExpBuffer(query);
4961}
4962
4963/*
4964 * dumpPublicationNamespace
4965 * dump the definition of the given publication schema mapping.
4966 */
4967static void
4969{
4973 PQExpBuffer query;
4974 char *tag;
4975
4976 /* Do nothing if not dumping schema */
4978 return;
4979
4981
4982 query = createPQExpBuffer();
4983
4986
4987 /*
4988 * There is no point in creating drop query as the drop is done by schema
4989 * drop.
4990 */
4993 ARCHIVE_OPTS(.tag = tag,
4995 .owner = pubinfo->rolname,
4996 .description = "PUBLICATION TABLES IN SCHEMA",
4997 .section = SECTION_POST_DATA,
4998 .createStmt = query->data));
4999
5000 /* These objects can't currently have comments or seclabels */
5001
5002 pfree(tag);
5003 destroyPQExpBuffer(query);
5004}
5005
5006/*
5007 * dumpPublicationTable
5008 * dump the definition of the given publication table mapping
5009 */
5010static void
5012{
5016 PQExpBuffer query;
5017 char *tag;
5018
5019 /* Do nothing if not dumping schema */
5021 return;
5022
5024
5025 query = createPQExpBuffer();
5026
5031
5034
5036 {
5037 /*
5038 * It's necessary to add parentheses around the expression because
5039 * pg_get_expr won't supply the parentheses for things like WHERE
5040 * TRUE.
5041 */
5043 }
5045
5046 /*
5047 * There is no point in creating a drop query as the drop is done by table
5048 * drop. (If you think to change this, see also _printTocEntry().)
5049 * Although this object doesn't really have ownership as such, set the
5050 * owner field anyway to ensure that the command is run by the correct
5051 * role at restore time.
5052 */
5055 ARCHIVE_OPTS(.tag = tag,
5057 .owner = pubinfo->rolname,
5058 .description = "PUBLICATION TABLE",
5059 .section = SECTION_POST_DATA,
5060 .createStmt = query->data));
5061
5062 /* These objects can't currently have comments or seclabels */
5063
5064 pfree(tag);
5065 destroyPQExpBuffer(query);
5066}
5067
5068/*
5069 * Is the currently connected user a superuser?
5070 */
5071static bool
5073{
5076
5078
5080 return true;
5081
5082 return false;
5083}
5084
5085/*
5086 * Set the given value to restrict_nonsystem_relation_kind value. Since
5087 * restrict_nonsystem_relation_kind is introduced in minor version releases,
5088 * the setting query is effective only where available.
5089 */
5090static void
5092{
5094 PGresult *res;
5095
5096 appendPQExpBuffer(query,
5097 "SELECT set_config(name, '%s', false) "
5098 "FROM pg_settings "
5099 "WHERE name = 'restrict_nonsystem_relation_kind'",
5100 value);
5102
5103 PQclear(res);
5104 destroyPQExpBuffer(query);
5105}
5106
5107/*
5108 * getSubscriptions
5109 * get information about subscriptions
5110 */
5111void
5113{
5115 PQExpBuffer query;
5116 PGresult *res;
5117 SubscriptionInfo *subinfo;
5141 ntups;
5142
5144 return;
5145
5147 {
5148 int n;
5149
5151 "SELECT count(*) FROM pg_subscription "
5152 "WHERE subdbid = (SELECT oid FROM pg_database"
5153 " WHERE datname = current_database())",
5154 PGRES_TUPLES_OK);
5156 if (n > 0)
5158 PQclear(res);
5159 return;
5160 }
5161
5162 query = createPQExpBuffer();
5163
5164 /* Get the subscriptions in current database. */
5165 appendPQExpBufferStr(query,
5166 "SELECT s.tableoid, s.oid, s.subname,\n"
5167 " s.subowner,\n"
5168 " s.subconninfo, s.subslotname, s.subsynccommit,\n"
5169 " s.subpublications,\n");
5170
5173 else
5175
5178 else
5180
5182 appendPQExpBufferStr(query,
5183 " s.subtwophasestate,\n"
5184 " s.subdisableonerr,\n");
5185 else
5186 appendPQExpBuffer(query,
5187 " '%c' AS subtwophasestate,\n"
5188 " false AS subdisableonerr,\n",
5190
5192 appendPQExpBufferStr(query,
5193 " s.subpasswordrequired,\n"
5194 " s.subrunasowner,\n"
5195 " s.suborigin,\n");
5196 else
5197 appendPQExpBuffer(query,
5198 " 't' AS subpasswordrequired,\n"
5199 " 't' AS subrunasowner,\n"
5200 " '%s' AS suborigin,\n",
5201 LOGICALREP_ORIGIN_ANY);
5202
5205 " s.subenabled,\n");
5206 else
5208 " false AS subenabled,\n");
5209
5211 appendPQExpBufferStr(query,
5212 " s.subfailover,\n");
5213 else
5214 appendPQExpBufferStr(query,
5215 " false AS subfailover,\n");
5216
5218 appendPQExpBufferStr(query,
5219 " s.subretaindeadtuples,\n");
5220 else
5221 appendPQExpBufferStr(query,
5222 " false AS subretaindeadtuples,\n");
5223
5225 appendPQExpBufferStr(query,
5226 " s.submaxretention,\n");
5227 else
5229
5231 appendPQExpBufferStr(query,
5232 " s.subwalrcvtimeout,\n");
5233 else
5234 appendPQExpBufferStr(query,
5235 " '-1' AS subwalrcvtimeout,\n");
5236
5239 else
5241
5242 appendPQExpBufferStr(query,
5243 "FROM pg_subscription s\n");
5244
5246 appendPQExpBufferStr(query,
5247 "LEFT JOIN pg_catalog.pg_foreign_server fs \n"
5248 " ON fs.oid = s.subserver \n");
5249
5251 appendPQExpBufferStr(query,
5252 "LEFT JOIN pg_catalog.pg_replication_origin_status o \n"
5253 " ON o.external_id = 'pg_' || s.oid::text \n");
5254
5255 appendPQExpBufferStr(query,
5256 "WHERE s.subdbid = (SELECT oid FROM pg_database\n"
5257 " WHERE datname = current_database())");
5258
5260
5261 ntups = PQntuples(res);
5262
5263 /*
5264 * Get subscription fields. We don't include subskiplsn in the dump as
5265 * after restoring the dump this value may no longer be relevant.
5266 */
5289
5291
5293 {
5301
5306 else
5326 else
5331 else
5343 else
5346
5347 /* Decide whether we want to dump it */
5349 }
5350 PQclear(res);
5351
5352 destroyPQExpBuffer(query);
5353}
5354
5355/*
5356 * getSubscriptionRelations
5357 * Get information about subscription membership for dumpable relations. This
5358 * will be used only in binary-upgrade mode for PG17 or later versions.
5359 */
5360void
5362{
5366 PGresult *res;
5371 int ntups;
5373
5375 fout->remoteVersion < 170000)
5376 return;
5377
5379 "SELECT srsubid, srrelid, srsubstate, srsublsn "
5380 "FROM pg_catalog.pg_subscription_rel "
5381 "ORDER BY srsubid",
5382 PGRES_TUPLES_OK);
5383 ntups = PQntuples(res);
5384 if (ntups == 0)
5386
5387 /* Get pg_subscription_rel attributes */
5392
5395 {
5398 TableInfo *tblinfo;
5399
5400 /*
5401 * If we switched to a new subscription, check if the subscription
5402 * exists.
5403 */
5405 {
5409
5411 }
5412
5413 tblinfo = findTableByOid(relid);
5416 relid);
5417
5418 /* OK, make a DumpableObject for this relationship */
5430 else
5432
5433 /* Decide whether we want to dump it */
5435 }
5436
5437cleanup:
5438 PQclear(res);
5439}
5440
5441/*
5442 * dumpSubscriptionTable
5443 * Dump the definition of the given subscription table mapping. This will be
5444 * used only in binary-upgrade mode for PG17 or later versions.
5445 */
5446static void
5448{
5451 PQExpBuffer query;
5452 char *tag;
5453
5454 /* Do nothing if not dumping schema */
5456 return;
5457
5459
5461
5462 query = createPQExpBuffer();
5463
5465 {
5466 /*
5467 * binary_upgrade_add_sub_rel_state will add the subscription relation
5468 * to pg_subscription_rel table. This will be used only in
5469 * binary-upgrade mode.
5470 */
5471 appendPQExpBufferStr(query,
5472 "\n-- For binary upgrade, must preserve the subscriber table.\n");
5473 appendPQExpBufferStr(query,
5474 "SELECT pg_catalog.binary_upgrade_add_sub_rel_state(");
5476 appendPQExpBuffer(query,
5477 ", %u, '%c'",
5478 subrinfo->tblinfo->dobj.catId.oid,
5479 subrinfo->srsubstate);
5480
5483 else
5485
5487 }
5488
5489 /*
5490 * There is no point in creating a drop query as the drop is done by table
5491 * drop. (If you think to change this, see also _printTocEntry().)
5492 * Although this object doesn't really have ownership as such, set the
5493 * owner field anyway to ensure that the command is run by the correct
5494 * role at restore time.
5495 */
5498 ARCHIVE_OPTS(.tag = tag,
5500 .owner = subinfo->rolname,
5501 .description = "SUBSCRIPTION TABLE",
5502 .section = SECTION_POST_DATA,
5503 .createStmt = query->data));
5504
5505 /* These objects can't currently have comments or seclabels */
5506
5507 pfree(tag);
5508 destroyPQExpBuffer(query);
5509}
5510
5511/*
5512 * dumpSubscription
5513 * dump the definition of the given subscription
5514 */
5515static void
5517{
5520 PQExpBuffer query;
5521 PQExpBuffer publications;
5526
5527 /* Do nothing if not dumping schema */
5529 return;
5530
5532 query = createPQExpBuffer();
5533
5535
5537 qsubname);
5538
5540 qsubname);
5542 {
5544 }
5545 else
5546 {
5549 }
5550
5551 /* Build list of quoted publications and append them to query. */
5554
5555 publications = createPQExpBuffer();
5557 {
5560
5562 }
5563
5564 appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
5567 else
5569
5572
5577 else
5579
5582
5585
5588
5591
5594
5597
5600
5603
5606
5609
5611
5612 /*
5613 * In binary-upgrade mode, we allow the replication to continue after the
5614 * upgrade.
5615 */
5617 {
5619 {
5620 /*
5621 * Preserve the remote_lsn for the subscriber's replication
5622 * origin. This value is required to start the replication from
5623 * the position before the upgrade. This value will be stale if
5624 * the publisher gets upgraded before the subscriber node.
5625 * However, this shouldn't be a problem as the upgrade of the
5626 * publisher ensures that all the transactions were replicated
5627 * before upgrading it.
5628 */
5629 appendPQExpBufferStr(query,
5630 "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
5631 appendPQExpBufferStr(query,
5632 "SELECT pg_catalog.binary_upgrade_replorigin_advance(");
5635 }
5636
5638 {
5639 /*
5640 * Enable the subscription to allow the replication to continue
5641 * after the upgrade.
5642 */
5643 appendPQExpBufferStr(query,
5644 "\n-- For binary upgrade, must preserve the subscriber's running state.\n");
5646 }
5647 }
5648
5652 .owner = subinfo->rolname,
5653 .description = "SUBSCRIPTION",
5654 .section = SECTION_POST_DATA,
5655 .createStmt = query->data,
5656 .dropStmt = delq->data));
5657
5662
5667
5668 destroyPQExpBuffer(publications);
5670
5672 destroyPQExpBuffer(query);
5674}
5675
5676/*
5677 * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
5678 * the object needs.
5679 */
5680static void
5682 PQExpBuffer create,
5685 const char *keyword,
5686 const char *objname)
5687{
5689 {
5691 PGresult *res;
5692 PQExpBuffer query;
5693 int ntups;
5696
5697 /* dodge fmtId() non-reentrancy */
5699
5700 query = createPQExpBuffer();
5701 appendPQExpBuffer(query,
5702 "SELECT e.extname "
5703 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5704 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5705 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5706 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5707 catalog,
5710 ntups = PQntuples(res);
5713 {
5715 keyword, nm,
5717 }
5718
5719 PQclear(res);
5720 destroyPQExpBuffer(query);
5722 }
5723}
5724
5727{
5728 /*
5729 * If the old version didn't assign an array type, but the new version
5730 * does, we must select an unused type OID to assign. This currently only
5731 * happens for domains, when upgrading pre-v11 to v11 and up.
5732 *
5733 * Note: local state here is kind of ugly, but we must have some, since we
5734 * mustn't choose the same unused OID more than once.
5735 */
5737 PGresult *res;
5739
5740 do
5741 {
5742 ++next_possible_free_oid;
5744 "SELECT EXISTS(SELECT 1 "
5745 "FROM pg_catalog.pg_type "
5746 "WHERE oid = '%u'::pg_catalog.oid);",
5747 next_possible_free_oid);
5750 PQclear(res);
5752
5754}
5755
5756static void
5762{
5764 PGresult *res;
5769
5772 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5773 pg_type_oid);
5774
5778 else
5780
5783
5785 {
5787 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5789 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5790 pg_type_array_oid);
5791 }
5792
5793 /*
5794 * Pre-set the multirange type oid and its own array type oid.
5795 */
5797 {
5799 {
5801 "SELECT t.oid, t.typarray "
5802 "FROM pg_catalog.pg_type t "
5803 "JOIN pg_catalog.pg_range r "
5804 "ON t.oid = r.rngmultitypid "
5805 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5806 pg_type_oid);
5807
5809
5812
5813 PQclear(res);
5814 }
5815 else
5816 {
5819 }
5820
5822 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5824 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5825 pg_type_multirange_oid);
5827 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5829 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5830 pg_type_multirange_array_oid);
5831 }
5832
5834}
5835
5836static void
5840{
5842
5846}
5847
5848/*
5849 * bsearch() comparator for BinaryUpgradeClassOidItem
5850 */
5851static int
5853{
5856
5858}
5859
5860/*
5861 * collectBinaryUpgradeClassOids
5862 *
5863 * Construct a table of pg_class information required for
5864 * binary_upgrade_set_pg_class_oids(). The table is sorted by OID for speed in
5865 * lookup.
5866 */
5867static void
5869{
5870 PGresult *res;
5871 const char *query;
5872
5873 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5874 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5875 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5876 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5877 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5878 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5879 "ORDER BY c.oid;";
5880
5882
5884 binaryUpgradeClassOids =
5886
5888 {
5896 }
5897
5898 PQclear(res);
5899}
5900
5901static void
5904{
5906 BinaryUpgradeClassOidItem *entry;
5907
5909
5910 /*
5911 * Preserve the OID and relfilenumber of the table, table's index, table's
5912 * toast table and toast table's index if any.
5913 *
5914 * One complexity is that the current table definition might not require
5915 * the creation of a TOAST table, but the old database might have a TOAST
5916 * table that was created earlier, before some wide columns were dropped.
5917 * By setting the TOAST oid we force creation of the TOAST heap and index
5918 * by the new backend, so we can copy the files during binary upgrade
5919 * without worrying about this case.
5920 */
5924 BinaryUpgradeClassOidItemCmp);
5925
5927 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5928
5931 {
5933 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5934 pg_class_oid);
5935
5936 /*
5937 * Not every relation has storage. Also, in a pre-v12 database,
5938 * partitioned tables have a relfilenumber, which should not be
5939 * preserved when upgrading.
5940 */
5944 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5945 entry->relfilenumber);
5946
5947 /*
5948 * In a pre-v12 database, partitioned tables might be marked as having
5949 * toast tables, but we should ignore them if so.
5950 */
5953 {
5955 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
5956 entry->toast_oid);
5958 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
5959 entry->toast_relfilenumber);
5960
5961 /* every toast table has an index */
5963 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5964 entry->toast_index_oid);
5966 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5967 entry->toast_index_relfilenumber);
5968 }
5969 }
5970 else
5971 {
5972 /* Preserve the OID and relfilenumber of the index */
5974 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5975 pg_class_oid);
5977 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5978 entry->relfilenumber);
5979 }
5980
5982}
5983
5984/*
5985 * If the DumpableObject is a member of an extension, add a suitable
5986 * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
5987 *
5988 * For somewhat historical reasons, objname should already be quoted,
5989 * but not objnamespace (if any).
5990 */
5991static void
5994 const char *objtype,
5995 const char *objname,
5997{
6000
6002 return;
6003
6004 /*
6005 * Find the parent extension. We could avoid this search if we wanted to
6006 * add a link field to DumpableObject, but the space costs of that would
6007 * be considerable. We assume that member objects could only have a
6008 * direct dependency on their own extension, not any others.
6009 */
6011 {
6014 break;
6016 }
6019 objtype, objname);
6020
6022 "\n-- For binary upgrade, handle extension membership the hard way\n");
6025 objtype);
6029}
6030
6031/*
6032 * getNamespaces:
6033 * get information about all namespaces in the system catalogs
6034 */
6035void
6037{
6038 PGresult *res;
6039 int ntups;
6041 PQExpBuffer query;
6049
6050 query = createPQExpBuffer();
6051
6052 /*
6053 * we fetch all namespaces including system ones, so that every object we
6054 * read in can be linked to a containing namespace.
6055 */
6057 "n.nspowner, "
6058 "n.nspacl, "
6059 "acldefault('n', n.nspowner) AS acldefault "
6060 "FROM pg_namespace n");
6061
6063
6064 ntups = PQntuples(res);
6065
6067
6074
6076 {
6077 const char *nspowner;
6078
6091
6092 /* Decide whether to dump this namespace */
6094
6095 /* Mark whether namespace has an ACL */
6098
6099 /*
6100 * We ignore any pg_init_privs.initprivs entry for the public schema
6101 * and assume a predetermined default, for several reasons. First,
6102 * dropping and recreating the schema removes its pg_init_privs entry,
6103 * but an empty destination database starts with this ACL nonetheless.
6104 * Second, we support dump/reload of public schema ownership changes.
6105 * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
6106 * initprivs continues to reflect the initial owner. Hence,
6107 * synthesize the value that nspacl will have after the restore's
6108 * ALTER SCHEMA OWNER. Third, this makes the destination database
6109 * match the source's ACL, even if the latter was an initdb-default
6110 * ACL, which changed in v15. An upgrade pulls in changes to most
6111 * system object ACLs that the DBA had not customized. We've made the
6112 * public schema depart from that, because changing its ACL so easily
6113 * breaks applications.
6114 */
6116 {
6119
6120 /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
6131
6135
6138 }
6139 }
6140
6141 PQclear(res);
6142 destroyPQExpBuffer(query);
6143}
6144
6145/*
6146 * findNamespace:
6147 * given a namespace OID, look up the info read by getNamespaces
6148 */
6151{
6153
6158}
6159
6160/*
6161 * getExtensions:
6162 * read all extensions in the system catalogs and return them in the
6163 * ExtensionInfo* structure
6164 *
6165 * numExtensions is set to the number of extensions read in
6166 */
6167ExtensionInfo *
6169{
6171 PGresult *res;
6172 int ntups;
6174 PQExpBuffer query;
6184
6185 query = createPQExpBuffer();
6186
6188 "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
6189 "FROM pg_extension x "
6190 "JOIN pg_namespace n ON n.oid = x.extnamespace");
6191
6193
6194 ntups = PQntuples(res);
6195 if (ntups == 0)
6197
6199
6208
6210 {
6221
6222 /* Decide whether we want to dump it */
6224 }
6225
6226cleanup:
6227 PQclear(res);
6228 destroyPQExpBuffer(query);
6229
6230 *numExtensions = ntups;
6231
6233}
6234
6235/*
6236 * getTypes:
6237 * get information about all types in the system catalogs
6238 *
6239 * NB: this must run after getFuncs() because we assume we can do
6240 * findFuncByOid().
6241 */
6242void
6244{
6245 PGresult *res;
6246 int ntups;
6265
6266 /*
6267 * we include even the built-in types because those may be used as array
6268 * elements by user-defined types
6269 *
6270 * we filter out the built-in types when we dump out the types
6271 *
6272 * same approach for undefined (shell) types and array types
6273 *
6274 * Note: as of 8.3 we can reliably detect whether a type is an
6275 * auto-generated array type by checking the element type's typarray.
6276 * (Before that the test is capable of generating false positives.) We
6277 * still check for name beginning with '_', though, so as to avoid the
6278 * cost of the subselect probe for all standard types. This would have to
6279 * be revisited if the backend ever allows renaming of array types.
6280 */
6282 "typnamespace, typacl, "
6283 "acldefault('T', typowner) AS acldefault, "
6284 "typowner, "
6285 "typelem, typrelid, typarray, "
6286 "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
6287 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
6288 "typtype, typisdefined, "
6289 "typname[0] = '_' AND typelem != 0 AND "
6290 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
6291 "FROM pg_type");
6292
6294
6295 ntups = PQntuples(res);
6296
6298
6313
6315 {
6334
6337 else
6339
6342 else
6344
6346
6349 else
6351
6352 /* Decide whether we want to dump it */
6354
6355 /* Mark whether type has an ACL */
6358
6359 /*
6360 * If it's a domain, fetch info about its constraints, if any
6361 */
6368
6369 /*
6370 * If it's a base type, make a DumpableObject representing a shell
6371 * definition of the type. We will need to dump that ahead of the I/O
6372 * functions for the type. Similarly, range types need a shell
6373 * definition in case they have a canonicalize function.
6374 *
6375 * Note: the shell type doesn't have a catId. You might think it
6376 * should copy the base type's catId, but then it might capture the
6377 * pg_depend entries for the type, which we don't want.
6378 */
6382 {
6391
6392 /*
6393 * Initially mark the shell type as not to be dumped. We'll only
6394 * dump it if the I/O or canonicalize functions need to be dumped;
6395 * this is taken care of while sorting dependencies.
6396 */
6398 }
6399 }
6400
6401 PQclear(res);
6402
6403 destroyPQExpBuffer(query);
6404}
6405
6406/*
6407 * getOperators:
6408 * get information about all operators in the system catalogs
6409 */
6410void
6412{
6413 PGresult *res;
6414 int ntups;
6427
6428 /*
6429 * find all operators, including builtin operators; we filter out
6430 * system-defined operators at dump-out time.
6431 */
6432
6434 "oprnamespace, "
6435 "oprowner, "
6436 "oprkind, "
6437 "oprleft, "
6438 "oprright, "
6439 "oprcode::oid AS oprcode "
6440 "FROM pg_operator");
6441
6443
6444 ntups = PQntuples(res);
6445
6447
6457
6459 {
6472
6473 /* Decide whether we want to dump it */
6475 }
6476
6477 PQclear(res);
6478
6479 destroyPQExpBuffer(query);
6480}
6481
6482/*
6483 * getCollations:
6484 * get information about all collations in the system catalogs
6485 */
6486void
6488{
6489 PGresult *res;
6490 int ntups;
6492 PQExpBuffer query;
6500
6501 query = createPQExpBuffer();
6502
6503 /*
6504 * find all collations, including builtin collations; we filter out
6505 * system-defined collations at dump-out time.
6506 */
6507
6509 "collnamespace, "
6510 "collowner, "
6511 "collencoding "
6512 "FROM pg_collation");
6513
6515
6516 ntups = PQntuples(res);
6517
6519
6526
6528 {
6538
6539 /* Decide whether we want to dump it */
6541 }
6542
6543 PQclear(res);
6544
6545 destroyPQExpBuffer(query);
6546}
6547
6548/*
6549 * getConversions:
6550 * get information about all conversions in the system catalogs
6551 */
6552void
6554{
6555 PGresult *res;
6556 int ntups;
6558 PQExpBuffer query;
6565
6566 query = createPQExpBuffer();
6567
6568 /*
6569 * find all conversions, including builtin conversions; we filter out
6570 * system-defined conversions at dump-out time.
6571 */
6572
6574 "connamespace, "
6575 "conowner "
6576 "FROM pg_conversion");
6577
6579
6580 ntups = PQntuples(res);
6581
6583
6589
6591 {
6600
6601 /* Decide whether we want to dump it */
6603 }
6604
6605 PQclear(res);
6606
6607 destroyPQExpBuffer(query);
6608}
6609
6610/*
6611 * getAccessMethods:
6612 * get information about all user-defined access methods
6613 */
6614void
6616{
6617 PGresult *res;
6618 int ntups;
6620 PQExpBuffer query;
6627
6628 query = createPQExpBuffer();
6629
6630 /*
6631 * Select all access methods from pg_am table.
6632 */
6634 appendPQExpBufferStr(query,
6635 "amtype, "
6636 "amhandler::pg_catalog.regproc AS amhandler ");
6638
6640
6641 ntups = PQntuples(res);
6642
6644
6650
6652 {
6661
6662 /* Decide whether we want to dump it */
6664 }
6665
6666 PQclear(res);
6667
6668 destroyPQExpBuffer(query);
6669}
6670
6671
6672/*
6673 * getOpclasses:
6674 * get information about all opclasses in the system catalogs
6675 */
6676void
6678{
6679 PGresult *res;
6680 int ntups;
6690
6691 /*
6692 * find all opclasses, including builtin opclasses; we filter out
6693 * system-defined opclasses at dump-out time.
6694 */
6695
6697 "opcnamespace, "
6698 "opcowner "
6699 "FROM pg_opclass");
6700
6702
6703 ntups = PQntuples(res);
6704
6706
6713
6715 {
6725
6726 /* Decide whether we want to dump it */
6728 }
6729
6730 PQclear(res);
6731
6732 destroyPQExpBuffer(query);
6733}
6734
6735/*
6736 * getOpfamilies:
6737 * get information about all opfamilies in the system catalogs
6738 */
6739void
6741{
6742 PGresult *res;
6743 int ntups;
6745 PQExpBuffer query;
6753
6754 query = createPQExpBuffer();
6755
6756 /*
6757 * find all opfamilies, including builtin opfamilies; we filter out
6758 * system-defined opfamilies at dump-out time.
6759 */
6760
6762 "opfnamespace, "
6763 "opfowner "
6764 "FROM pg_opfamily");
6765
6767
6768 ntups = PQntuples(res);
6769
6771
6778
6780 {
6790
6791 /* Decide whether we want to dump it */
6793 }
6794
6795 PQclear(res);
6796
6797 destroyPQExpBuffer(query);
6798}
6799
6800/*
6801 * getAggregates:
6802 * get information about all user-defined aggregates in the system catalogs
6803 */
6804void
6806{
6808 PGresult *res;
6809 int ntups;
6823
6824 /*
6825 * Find all interesting aggregates. See comment in getFuncs() for the
6826 * rationale behind the filtering logic.
6827 */
6829 : "p.proisagg");
6830
6832 "p.proname AS aggname, "
6833 "p.pronamespace AS aggnamespace, "
6834 "p.pronargs, p.proargtypes, "
6835 "p.proowner, "
6836 "p.proacl AS aggacl, "
6837 "acldefault('f', p.proowner) AS acldefault "
6838 "FROM pg_proc p "
6839 "LEFT JOIN pg_init_privs pip ON "
6840 "(p.oid = pip.objoid "
6841 "AND pip.classoid = 'pg_proc'::regclass "
6842 "AND pip.objsubid = 0) "
6843 "WHERE %s AND ("
6844 "p.pronamespace != "
6845 "(SELECT oid FROM pg_namespace "
6846 "WHERE nspname = 'pg_catalog') OR "
6847 "p.proacl IS DISTINCT FROM pip.initprivs",
6848 agg_check);
6850 appendPQExpBufferStr(query,
6851 " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6852 "classid = 'pg_proc'::regclass AND "
6853 "objid = p.oid AND "
6854 "refclassid = 'pg_extension'::regclass AND "
6855 "deptype = 'e')");
6857
6859
6860 ntups = PQntuples(res);
6861
6863
6873
6875 {
6893 else
6894 {
6899 }
6901
6902 /* Decide whether we want to dump it */
6904
6905 /* Mark whether aggregate has an ACL */
6908 }
6909
6910 PQclear(res);
6911
6912 destroyPQExpBuffer(query);
6913}
6914
6915/*
6916 * getFuncs:
6917 * get information about all user-defined functions in the system catalogs
6918 */
6919void
6921{
6923 PGresult *res;
6924 int ntups;
6927 FuncInfo *finfo;
6940
6941 /*
6942 * Find all interesting functions. This is a bit complicated:
6943 *
6944 * 1. Always exclude aggregates; those are handled elsewhere.
6945 *
6946 * 2. Always exclude functions that are internally dependent on something
6947 * else, since presumably those will be created as a result of creating
6948 * the something else. This currently acts only to suppress constructor
6949 * functions for range types. Note this is OK only because the
6950 * constructors don't have any dependencies the range type doesn't have;
6951 * otherwise we might not get creation ordering correct.
6952 *
6953 * 3. Otherwise, we normally exclude functions in pg_catalog. However, if
6954 * they're members of extensions and we are in binary-upgrade mode then
6955 * include them, since we want to dump extension members individually in
6956 * that mode. Also, if they are used by casts or transforms then we need
6957 * to gather the information about them, though they won't be dumped if
6958 * they are built-in. Also, include functions in pg_catalog if they have
6959 * an ACL different from what's shown in pg_init_privs (so we have to join
6960 * to pg_init_privs; annoying).
6961 */
6963 : "NOT p.proisagg");
6964
6965 appendPQExpBuffer(query,
6966 "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
6967 "p.pronargs, p.proargtypes, p.prorettype, "
6968 "p.proacl, "
6969 "acldefault('f', p.proowner) AS acldefault, "
6970 "p.pronamespace, "
6971 "p.proowner "
6972 "FROM pg_proc p "
6973 "LEFT JOIN pg_init_privs pip ON "
6974 "(p.oid = pip.objoid "
6975 "AND pip.classoid = 'pg_proc'::regclass "
6976 "AND pip.objsubid = 0) "
6977 "WHERE %s"
6978 "\n AND NOT EXISTS (SELECT 1 FROM pg_depend "
6979 "WHERE classid = 'pg_proc'::regclass AND "
6980 "objid = p.oid AND deptype = 'i')"
6981 "\n AND ("
6982 "\n pronamespace != "
6983 "(SELECT oid FROM pg_namespace "
6984 "WHERE nspname = 'pg_catalog')"
6985 "\n OR EXISTS (SELECT 1 FROM pg_cast"
6986 "\n WHERE pg_cast.oid > %u "
6987 "\n AND p.oid = pg_cast.castfunc)"
6988 "\n OR EXISTS (SELECT 1 FROM pg_transform"
6989 "\n WHERE pg_transform.oid > %u AND "
6990 "\n (p.oid = pg_transform.trffromsql"
6991 "\n OR p.oid = pg_transform.trftosql))",
6992 not_agg_check,
6993 g_last_builtin_oid,
6994 g_last_builtin_oid);
6996 appendPQExpBufferStr(query,
6997 "\n OR EXISTS(SELECT 1 FROM pg_depend WHERE "
6998 "classid = 'pg_proc'::regclass AND "
6999 "objid = p.oid AND "
7000 "refclassid = 'pg_extension'::regclass AND "
7001 "deptype = 'e')");
7002 appendPQExpBufferStr(query,
7003 "\n OR p.proacl IS DISTINCT FROM pip.initprivs");
7005
7007
7008 ntups = PQntuples(res);
7009
7011
7023
7025 {
7043 else
7044 {
7048 }
7050
7051 /* Decide whether we want to dump it */
7053
7054 /* Mark whether function has an ACL */
7057 }
7058
7059 PQclear(res);
7060
7061 destroyPQExpBuffer(query);
7062}
7063
7064/*
7065 * getRelationStatistics
7066 * register the statistics object as a dependent of the relation.
7067 *
7068 * reltuples is passed as a string to avoid complexities in converting from/to
7069 * floating point.
7070 */
7075 char **indAttNames, int nindAttNames)
7076{
7079
7081 (relkind == RELKIND_PARTITIONED_TABLE) ||
7082 (relkind == RELKIND_INDEX) ||
7083 (relkind == RELKIND_PARTITIONED_INDEX) ||
7084 (relkind == RELKIND_MATVIEW ||
7085 relkind == RELKIND_FOREIGN_TABLE))
7086 {
7089
7093 AssignDumpId(dobj);
7096 dobj->nDeps = 1;
7097 dobj->allocDeps = 1;
7100 dobj->namespace = rel->namespace;
7102 info->relpages = relpages;
7104 info->relallvisible = relallvisible;
7105 info->relallfrozen = relallfrozen;
7106 info->relkind = relkind;
7107 info->indAttNames = indAttNames;
7108 info->nindAttNames = nindAttNames;
7109
7110 /*
7111 * Ordinarily, stats go in SECTION_DATA for tables and
7112 * SECTION_POST_DATA for indexes.
7113 *
7114 * However, the section may be updated later for materialized view
7115 * stats. REFRESH MATERIALIZED VIEW replaces the storage and resets
7116 * the stats, so the stats must be restored after the data. Also, the
7117 * materialized view definition may be postponed to SECTION_POST_DATA
7118 * (see repairMatViewBoundaryMultiLoop()).
7119 */
7121 {
7127 break;
7131 break;
7132 default:
7134 info->relkind);
7135 }
7136
7137 return info;
7138 }
7140}
7141
7142/*
7143 * getTables
7144 * read all the tables (no indexes) in the system catalogs,
7145 * and return them as an array of TableInfo structures
7146 *
7147 * *numTables is set to the number of tables read in
7148 */
7149TableInfo *
7151{
7153 PGresult *res;
7154 int ntups;
7157 TableInfo *tblinfo;
7198
7199 /*
7200 * Find all the tables and table-like objects.
7201 *
7202 * We must fetch all tables in this phase because otherwise we cannot
7203 * correctly identify inherited columns, owned sequences, etc.
7204 *
7205 * We include system catalogs, so that we can work if a user table is
7206 * defined to inherit from a system catalog (pretty weird, but...)
7207 *
7208 * Note: in this phase we should collect only a minimal amount of
7209 * information about each table, basically just enough to decide if it is
7210 * interesting. In particular, since we do not yet have lock on any user
7211 * table, we MUST NOT invoke any server-side data collection functions
7212 * (for instance, pg_get_partkeydef()). Those are likely to fail or give
7213 * wrong answers if any concurrent DDL is happening.
7214 */
7215
7216 appendPQExpBufferStr(query,
7217 "SELECT c.tableoid, c.oid, c.relname, "
7218 "c.relnamespace, c.relkind, c.reltype, "
7219 "c.relowner, "
7220 "c.relchecks, "
7221 "c.relhasindex, c.relhasrules, c.relpages, "
7222 "c.reltuples, c.relallvisible, ");
7223
7226 else
7228
7229 appendPQExpBufferStr(query,
7230 "c.relhastriggers, c.relpersistence, "
7231 "c.reloftype, "
7232 "c.relacl, "
7233 "acldefault(CASE"
7235 /* 19beta1 didn't support acldefault('g'), so we'll fix that below */
7236 appendPQExpBufferStr(query,
7237 fout->remoteVersion >= 200000 ?
7238 " THEN 'g'::\"char\"" :
7239 " THEN NULL");
7240 appendPQExpBufferStr(query,
7242 " THEN 's'::\"char\""
7243 " ELSE 'r'::\"char\" END, c.relowner) AS acldefault, "
7245 "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
7246 "ELSE 0 END AS foreignserver, "
7247 "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
7248 "tc.oid AS toid, "
7249 "tc.relpages AS toastpages, "
7250 "tc.reloptions AS toast_reloptions, "
7251 "d.refobjid AS owning_tab, "
7252 "d.refobjsubid AS owning_col, "
7253 "tsp.spcname AS reltablespace, ");
7254
7256 appendPQExpBufferStr(query,
7257 "false AS relhasoids, ");
7258 else
7259 appendPQExpBufferStr(query,
7260 "c.relhasoids, ");
7261
7262 appendPQExpBufferStr(query,
7263 "c.relispopulated, ");
7264
7265 appendPQExpBufferStr(query,
7266 "c.relreplident, ");
7267
7268 appendPQExpBufferStr(query,
7269 "c.relrowsecurity, c.relforcerowsecurity, ");
7270
7271 appendPQExpBufferStr(query,
7272 "c.relminmxid, tc.relminmxid AS tminmxid, ");
7273
7274 appendPQExpBufferStr(query,
7275 "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
7276 "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
7277 "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
7278
7279 appendPQExpBufferStr(query,
7280 "am.amname, ");
7281
7282 appendPQExpBufferStr(query,
7283 "(d.deptype = 'i') IS TRUE AS is_identity_sequence, ");
7284
7285 appendPQExpBufferStr(query,
7286 "c.relispartition AS ispartition ");
7287
7288 /*
7289 * Left join to pg_depend to pick up dependency info linking sequences to
7290 * their owning column, if any (note this dependency is AUTO except for
7291 * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
7292 * collect the spcname.
7293 */
7294 appendPQExpBufferStr(query,
7295 "\nFROM pg_class c\n"
7296 "LEFT JOIN pg_depend d ON "
7298 "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
7299 "d.objsubid = 0 AND "
7300 "d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i'))\n"
7301 "LEFT JOIN pg_tablespace tsp ON (tsp.oid = c.reltablespace)\n");
7302
7303 /*
7304 * Left join to pg_am to pick up the amname.
7305 */
7306 appendPQExpBufferStr(query,
7307 "LEFT JOIN pg_am am ON (c.relam = am.oid)\n");
7308
7309 /*
7310 * We purposefully ignore toast OIDs for partitioned tables; the reason is
7311 * that versions 10 and 11 have them, but later versions do not, so
7312 * emitting them causes the upgrade to fail.
7313 */
7314 appendPQExpBufferStr(query,
7315 "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
7318
7319 /*
7320 * Restrict to interesting relkinds (in particular, not indexes). Not all
7321 * relkinds are possible in older servers, but it's not worth the trouble
7322 * to emit a version-dependent list.
7323 *
7324 * Composite-type table entries won't be dumped as such, but we have to
7325 * make a DumpableObject for them so that we can track dependencies of the
7326 * composite type (pg_depend entries for columns of the composite type
7327 * link to the pg_class entry not the pg_type entry).
7328 */
7329 appendPQExpBufferStr(query,
7330 "WHERE c.relkind IN ("
7339 "ORDER BY c.oid");
7340
7342
7343 ntups = PQntuples(res);
7344
7345 *numTables = ntups;
7346
7347 /*
7348 * Extract data from result and lock dumpable tables. We do the locking
7349 * before anything else, to minimize the window wherein a table could
7350 * disappear under us.
7351 *
7352 * Note that we have to save info about all tables here, even when dumping
7353 * only one, because we don't yet know which tables might be inheritance
7354 * ancestors of the target table.
7355 */
7357
7398
7400 {
7401 /*
7402 * Arrange to fail instead of waiting forever for a table lock.
7403 *
7404 * NB: this coding assumes that the only queries issued within the
7405 * following loop are LOCK TABLEs; else the timeout may be undesirably
7406 * applied to other things too.
7407 */
7408 resetPQExpBuffer(query);
7412 }
7413
7414 resetPQExpBuffer(query);
7415
7417 {
7420
7429 /* acldefault computed below */
7441 else
7444 {
7447 }
7448 else
7449 {
7452 }
7469 else
7476 else
7478 tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
7480
7482 !(fout->remoteVersion >= 200000))
7483 {
7486
7487 /* Standard ACL as of v19 is {owner=r/owner} */
7494
7496
7499 }
7500 else
7502
7503 /* other fields were zeroed above */
7504
7505 /*
7506 * Decide whether we want to dump this table.
7507 */
7510 else
7512
7513 /*
7514 * Now, consider the table "interesting" if we need to dump its
7515 * definition, data or its statistics. Later on, we'll skip a lot of
7516 * data collection for uninteresting tables.
7517 *
7518 * Note: the "interesting" flag will also be set by flagInhTables for
7519 * parents of interesting tables, so that we collect necessary
7520 * inheritance info even when the parents are not themselves being
7521 * dumped. This is the main reason why we need an "interesting" flag
7522 * that's separate from the components-to-dump bitmask.
7523 */
7525 (DUMP_COMPONENT_DEFINITION |
7526 DUMP_COMPONENT_DATA |
7527 DUMP_COMPONENT_STATISTICS)) != 0;
7528
7531
7532 /* Tables have data */
7534
7535 /* Mark whether table has an ACL */
7539
7540 /* Add statistics */
7542 {
7543 RelStatsInfo *stats;
7544
7546 tblinfo[i].relpages,
7548 relallvisible, relallfrozen,
7552 }
7553
7554 /*
7555 * Read-lock target tables to make sure they aren't DROPPED or altered
7556 * in schema before we get around to dumping them.
7557 *
7558 * Note that we don't explicitly lock parents of the target tables; we
7559 * assume our lock on the child is enough to prevent schema
7560 * alterations to parent tables.
7561 *
7562 * NOTE: it'd be kinda nice to lock other relations too, not only
7563 * plain or partitioned tables, but the backend doesn't presently
7564 * allow that.
7565 *
7566 * We only need to lock the table for certain components; see
7567 * pg_dump.h
7568 */
7572 {
7573 /*
7574 * Tables are locked in batches. When dumping from a remote
7575 * server this can save a significant amount of time by reducing
7576 * the number of round trips.
7577 */
7581 else
7582 {
7585
7586 /* Arbitrarily end a batch when query length reaches 100K. */
7588 {
7589 /* Lock another batch of tables. */
7592 resetPQExpBuffer(query);
7593 }
7594 }
7595 }
7596 }
7597
7599 {
7600 /* Lock the tables in the last batch. */
7603 }
7604
7606 {
7608 }
7609
7610 PQclear(res);
7611
7612 destroyPQExpBuffer(query);
7613
7614 return tblinfo;
7615}
7616
7617/*
7618 * getOwnedSeqs
7619 * identify owned sequences and mark them as dumpable if owning table is
7620 *
7621 * We used to do this in getTables(), but it's better to do it after the
7622 * index used by findTableByOid() has been set up.
7623 */
7624void
7626{
7628
7629 /*
7630 * Force sequences that are "owned" by table columns to be dumped whenever
7631 * their owning table is being dumped.
7632 */
7634 {
7636 TableInfo *owning_tab;
7637
7639 continue; /* not an owned sequence */
7640
7645
7646 /*
7647 * For an identity sequence, dump exactly the same components for the
7648 * sequence as for the owning table. This is important because we
7649 * treat the identity sequence as an integral part of the table. For
7650 * example, there is not any DDL command that allows creation of such
7651 * a sequence independently of the table.
7652 *
7653 * For other owned sequences such as serial sequences, we need to dump
7654 * the components that are being dumped for the table and any
7655 * components that the sequence is explicitly marked with.
7656 *
7657 * We can't simply use the set of components which are being dumped
7658 * for the table as the table might be in an extension (and only the
7659 * non-extension components, eg: ACLs if changed, security labels, and
7660 * policies, are being dumped) while the sequence is not (and
7661 * therefore the definition and other components should also be
7662 * dumped).
7663 *
7664 * If the sequence is part of the extension then it should be properly
7665 * marked by checkExtensionMembership() and this will be a no-op as
7666 * the table will be equivalently marked.
7667 */
7670 else
7672
7673 /* Make sure that necessary data is available if we're dumping it */
7675 {
7678 }
7679 }
7680}
7681
7682/*
7683 * getInherits
7684 * read all the inheritance information
7685 * from the system catalogs return them in the InhInfo* structure
7686 *
7687 * numInherits is set to the number of pairs read in
7688 */
7689InhInfo *
7691{
7692 PGresult *res;
7693 int ntups;
7697
7700
7701 /* find all the inheritance information */
7703
7705
7706 ntups = PQntuples(res);
7707
7708 *numInherits = ntups;
7709
7711
7714
7716 {
7719 }
7720
7721 PQclear(res);
7722
7723 destroyPQExpBuffer(query);
7724
7726}
7727
7728/*
7729 * getPartitioningInfo
7730 * get information about partitioning
7731 *
7732 * For the most part, we only collect partitioning info about tables we
7733 * intend to dump. However, this function has to consider all partitioned
7734 * tables in the database, because we need to know about parents of partitions
7735 * we are going to dump even if the parents themselves won't be dumped.
7736 *
7737 * Specifically, what we need to know is whether each partitioned table
7738 * has an "unsafe" partitioning scheme that requires us to force
7739 * load-via-partition-root mode for its children. Currently the only case
7740 * for which we force that is hash partitioning on enum columns, since the
7741 * hash codes depend on enum value OIDs which won't be replicated across
7742 * dump-and-reload. There are other cases in which load-via-partition-root
7743 * might be necessary, but we expect users to cope with them.
7744 */
7745void
7747{
7748 PQExpBuffer query;
7749 PGresult *res;
7750 int ntups;
7751
7752 /* hash partitioning didn't exist before v11 */
7754 return;
7755 /* needn't bother if not dumping data */
7757 return;
7758
7759 query = createPQExpBuffer();
7760
7761 /*
7762 * Unsafe partitioning schemes are exactly those for which hash enum_ops
7763 * appears among the partition opclasses. We needn't check partstrat.
7764 *
7765 * Note that this query may well retrieve info about tables we aren't
7766 * going to dump and hence have no lock on. That's okay since we need not
7767 * invoke any unsafe server-side functions.
7768 */
7769 appendPQExpBufferStr(query,
7770 "SELECT partrelid FROM pg_partitioned_table WHERE\n"
7771 "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
7772 "ON c.opcmethod = a.oid\n"
7773 "WHERE opcname = 'enum_ops' "
7774 "AND opcnamespace = 'pg_catalog'::regnamespace "
7775 "AND amname = 'hash') = ANY(partclass)");
7776
7778
7779 ntups = PQntuples(res);
7780
7782 {
7785
7789 tabrelid);
7791 }
7792
7793 PQclear(res);
7794
7795 destroyPQExpBuffer(query);
7796}
7797
7798/*
7799 * getIndexes
7800 * get information about every index on a dumpable table
7801 *
7802 * Note: index data is not returned directly to the caller, but it
7803 * does get entered into the DumpableObject tables.
7804 */
7805void
7807{
7810 PGresult *res;
7811 int ntups;
7815 i_oid,
7816 i_indrelid,
7817 i_indexname,
7818 i_relpages,
7819 i_reltuples,
7820 i_relallvisible,
7821 i_relallfrozen,
7822 i_parentidx,
7823 i_indexdef,
7824 i_indnkeyatts,
7825 i_indnatts,
7826 i_indkey,
7827 i_indisclustered,
7828 i_indisreplident,
7829 i_indnullsnotdistinct,
7830 i_contype,
7831 i_conname,
7832 i_condeferrable,
7833 i_condeferred,
7834 i_conperiod,
7835 i_contableoid,
7836 i_conoid,
7837 i_condef,
7838 i_indattnames,
7839 i_tablespace,
7840 i_indreloptions,
7841 i_indstatcols,
7842 i_indstatvals;
7843
7844 /*
7845 * We want to perform just one query against pg_index. However, we
7846 * mustn't try to select every row of the catalog and then sort it out on
7847 * the client side, because some of the server-side functions we need
7848 * would be unsafe to apply to tables we don't have lock on. Hence, we
7849 * build an array of the OIDs of tables we care about (and now have lock
7850 * on!), and use a WHERE clause to constrain which rows are selected.
7851 */
7854 {
7856
7858 continue;
7859
7860 /*
7861 * We can ignore indexes of uninteresting tables.
7862 */
7864 continue;
7865
7866 /* OK, we need info for this table */
7870 }
7872
7873 appendPQExpBufferStr(query,
7874 "SELECT t.tableoid, t.oid, i.indrelid, "
7875 "t.relname AS indexname, "
7876 "t.relpages, t.reltuples, t.relallvisible, ");
7877
7880 else
7882
7883 appendPQExpBufferStr(query,
7884 "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
7885 "i.indkey, i.indisclustered, "
7886 "c.contype, c.conname, "
7887 "c.condeferrable, c.condeferred, "
7888 "c.tableoid AS contableoid, "
7889 "c.oid AS conoid, "
7890 "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
7891 "CASE WHEN i.indexprs IS NOT NULL THEN "
7892 "(SELECT pg_catalog.array_agg(attname ORDER BY attnum)"
7893 " FROM pg_catalog.pg_attribute "
7894 " WHERE attrelid = i.indexrelid) "
7895 "ELSE NULL END AS indattnames, "
7896 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
7897 "t.reloptions AS indreloptions, ");
7898
7899
7900 appendPQExpBufferStr(query,
7901 "i.indisreplident, ");
7902
7904 appendPQExpBufferStr(query,
7905 "inh.inhparent AS parentidx, "
7906 "i.indnkeyatts AS indnkeyatts, "
7907 "i.indnatts AS indnatts, "
7908 "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
7909 " FROM pg_catalog.pg_attribute "
7910 " WHERE attrelid = i.indexrelid AND "
7911 " attstattarget >= 0) AS indstatcols, "
7912 "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
7913 " FROM pg_catalog.pg_attribute "
7914 " WHERE attrelid = i.indexrelid AND "
7915 " attstattarget >= 0) AS indstatvals, ");
7916 else
7917 appendPQExpBufferStr(query,
7918 "0 AS parentidx, "
7919 "i.indnatts AS indnkeyatts, "
7920 "i.indnatts AS indnatts, "
7921 "'' AS indstatcols, "
7922 "'' AS indstatvals, ");
7923
7925 appendPQExpBufferStr(query,
7926 "i.indnullsnotdistinct, ");
7927 else
7928 appendPQExpBufferStr(query,
7929 "false AS indnullsnotdistinct, ");
7930
7932 appendPQExpBufferStr(query,
7933 "c.conperiod ");
7934 else
7935 appendPQExpBufferStr(query,
7936 "NULL AS conperiod ");
7937
7938 /*
7939 * The point of the messy-looking outer join is to find a constraint that
7940 * is related by an internal dependency link to the index. If we find one,
7941 * create a CONSTRAINT entry linked to the INDEX entry. We assume an
7942 * index won't have more than one internal dependency.
7943 *
7944 * Note: the check on conrelid is redundant, but useful because that
7945 * column is indexed while conindid is not.
7946 */
7948 {
7949 appendPQExpBuffer(query,
7950 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
7951 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7952 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7953 "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
7954 "LEFT JOIN pg_catalog.pg_constraint c "
7955 "ON (i.indrelid = c.conrelid AND "
7956 "i.indexrelid = c.conindid AND "
7957 "c.contype IN ('p','u','x')) "
7958 "LEFT JOIN pg_catalog.pg_inherits inh "
7959 "ON (inh.inhrelid = indexrelid) "
7960 "WHERE (i.indisvalid OR t2.relkind = 'p') "
7961 "AND i.indisready "
7962 "ORDER BY i.indrelid, indexname",
7963 tbloids->data);
7964 }
7965 else
7966 {
7967 /*
7968 * the test on indisready is necessary in 9.2, and harmless in
7969 * earlier/later versions
7970 */
7971 appendPQExpBuffer(query,
7972 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
7973 "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
7974 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
7975 "LEFT JOIN pg_catalog.pg_constraint c "
7976 "ON (i.indrelid = c.conrelid AND "
7977 "i.indexrelid = c.conindid AND "
7978 "c.contype IN ('p','u','x')) "
7979 "WHERE i.indisvalid AND i.indisready "
7980 "ORDER BY i.indrelid, indexname",
7981 tbloids->data);
7982 }
7983
7985
7986 ntups = PQntuples(res);
7987
8017
8019
8020 /*
8021 * Outer loop iterates once per table, not once per row. Incrementing of
8022 * j is handled by the inner loop.
8023 */
8024 curtblindx = -1;
8026 {
8030
8031 /* Count rows for this table */
8034 break;
8035
8036 /*
8037 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8038 * order.
8039 */
8041 {
8044 break;
8045 }
8048 /* cross-check that we only got requested tables */
8050 !tbinfo->interesting)
8052 tbinfo->dobj.name);
8053
8054 /* Save data for this table */
8057
8059 {
8060 char contype;
8063 int nindAttNames = 0;
8068
8092 {
8094 };
8095
8098 else
8100
8102 {
8104 &indAttNames, &nindAttNames))
8106 }
8107
8110 relallvisible, relallfrozen, indexkind,
8111 indAttNames, nindAttNames);
8112
8114 if (contype == 'p' || contype == 'u' || contype == 'x')
8115 {
8116 /*
8117 * If we found a constraint matching the index, create an
8118 * entry for it.
8119 */
8121
8132 constrinfo->contype = contype;
8133 if (contype == 'x')
8135 else
8144
8148 }
8149 else
8150 {
8151 /* Plain secondary index */
8153 }
8154 }
8155 }
8156
8157 PQclear(res);
8158
8159 destroyPQExpBuffer(query);
8161}
8162
8163/*
8164 * getExtendedStatistics
8165 * get information about extended-statistics objects.
8166 *
8167 * Note: extended statistics data is not returned directly to the caller, but
8168 * it does get entered into the DumpableObject tables.
8169 */
8170void
8172{
8173 PQExpBuffer query;
8174 PGresult *res;
8176 int ntups;
8185
8186 query = createPQExpBuffer();
8187
8190 "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
8191 "FROM pg_catalog.pg_statistic_ext");
8192 else
8194 "stxnamespace, stxowner, stxrelid, stxstattarget "
8195 "FROM pg_catalog.pg_statistic_ext");
8196
8198
8199 ntups = PQntuples(res);
8200
8208
8210
8212 {
8225 else
8227
8228 /* Decide whether we want to dump it */
8230
8233 }
8234
8235 PQclear(res);
8236 destroyPQExpBuffer(query);
8237}
8238
8239/*
8240 * getConstraints
8241 *
8242 * Get info about constraints on dumpable tables.
8243 *
8244 * Currently handles foreign keys only.
8245 * Unique and primary key constraints are handled with indexes,
8246 * while check constraints are processed in getTableAttrs().
8247 */
8248void
8250{
8253 PGresult *res;
8254 int ntups;
8259 i_conoid,
8260 i_conrelid,
8261 i_conname,
8262 i_confrelid,
8263 i_conindid,
8264 i_condef;
8265
8266 /*
8267 * We want to perform just one query against pg_constraint. However, we
8268 * mustn't try to select every row of the catalog and then sort it out on
8269 * the client side, because some of the server-side functions we need
8270 * would be unsafe to apply to tables we don't have lock on. Hence, we
8271 * build an array of the OIDs of tables we care about (and now have lock
8272 * on!), and use a WHERE clause to constrain which rows are selected.
8273 */
8276 {
8278
8280 continue;
8281
8282 /* OK, we need info for this table */
8286 }
8288
8289 appendPQExpBufferStr(query,
8290 "SELECT c.tableoid, c.oid, "
8291 "conrelid, conname, confrelid, ");
8294 else
8296 appendPQExpBuffer(query,
8297 "pg_catalog.pg_get_constraintdef(c.oid) AS condef\n"
8298 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8299 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
8300 "WHERE contype = 'f' ",
8301 tbloids->data);
8303 appendPQExpBufferStr(query,
8304 "AND conparentid = 0 ");
8305 appendPQExpBufferStr(query,
8306 "ORDER BY conrelid, conname");
8307
8309
8310 ntups = PQntuples(res);
8311
8319
8321
8322 curtblindx = -1;
8324 {
8327
8328 /*
8329 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8330 * order.
8331 */
8333 {
8335 {
8338 break;
8339 }
8342 }
8343
8360
8361 /*
8362 * Restoring an FK that points to a partitioned table requires that
8363 * all partition indexes have been attached beforehand. Ensure that
8364 * happens by making the constraint depend on each index partition
8365 * attach object.
8366 */
8369 {
8371
8373 {
8375 {
8377
8378 /* not our index? */
8380 continue;
8381
8384 break;
8385 }
8386 }
8387 }
8388 }
8389
8390 PQclear(res);
8391
8392 destroyPQExpBuffer(query);
8394}
8395
8396/*
8397 * addConstrChildIdxDeps
8398 *
8399 * Recursive subroutine for getConstraints
8400 *
8401 * Given an object representing a foreign key constraint and an index on the
8402 * partitioned table it references, mark the constraint object as dependent
8403 * on the DO_INDEX_ATTACH object of each index partition, recursively
8404 * drilling down to their partitions if any. This ensures that the FK is not
8405 * restored until the index is fully marked valid.
8406 */
8407static void
8409{
8410 SimplePtrListCell *cell;
8411
8413
8415 {
8417
8419
8422 }
8423}
8424
8425/*
8426 * getDomainConstraints
8427 *
8428 * Get info about constraints on a domain.
8429 */
8430static void
8432{
8435 PGresult *res;
8437 i_oid,
8438 i_conname,
8439 i_consrc,
8440 i_convalidated,
8441 i_contype;
8442 int ntups;
8443
8445 {
8446 /*
8447 * Set up query for constraint-specific details. For servers 17 and
8448 * up, domains have constraints of type 'n' as well as 'c', otherwise
8449 * just the latter.
8450 */
8451 appendPQExpBuffer(query,
8452 "PREPARE getDomainConstraints(pg_catalog.oid) AS\n"
8453 "SELECT tableoid, oid, conname, "
8454 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
8455 "convalidated, contype "
8456 "FROM pg_catalog.pg_constraint "
8457 "WHERE contypid = $1 AND contype IN (%s) "
8458 "ORDER BY conname",
8460
8462
8464 }
8465
8466 printfPQExpBuffer(query,
8467 "EXECUTE getDomainConstraints('%u')",
8468 tyinfo->dobj.catId.oid);
8469
8471
8472 ntups = PQntuples(res);
8473
8480
8483
8484 /* 'i' tracks result rows; 'j' counts CHECK constraints */
8486 {
8489 ConstraintInfo *constraint;
8490
8492 {
8494 tyinfo->nDomChecks++;
8495 }
8496 else
8497 {
8500 /* use last item in array for the not-null constraint */
8502 constraint = tyinfo->notnull;
8503 }
8504
8513 constraint->contype = contype;
8516 constraint->conindex = 0;
8520
8522
8523 /*
8524 * Make the domain depend on the constraint, ensuring it won't be
8525 * output till any constraint dependencies are OK. If the constraint
8526 * has not been validated, it's going to be dumped after the domain
8527 * anyway, so this doesn't matter.
8528 */
8531 }
8532
8533 PQclear(res);
8534
8535 destroyPQExpBuffer(query);
8536}
8537
8538/*
8539 * getRules
8540 * get basic information about every rule in the system
8541 */
8542void
8544{
8545 PGresult *res;
8546 int ntups;
8557
8559 "tableoid, oid, rulename, "
8560 "ev_class AS ruletable, ev_type, is_instead, "
8561 "ev_enabled "
8562 "FROM pg_rewrite "
8563 "ORDER BY oid");
8564
8566
8567 ntups = PQntuples(res);
8568
8570
8578
8580 {
8582
8591 pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
8599 {
8600 /*
8601 * If the table is a view or materialized view, force its ON
8602 * SELECT rule to be sorted before the view itself --- this
8603 * ensures that any dependencies for the rule affect the table's
8604 * positioning. Other rules are forced to appear after their
8605 * table.
8606 */
8610 {
8613 /* We'll merge the rule into CREATE VIEW, if possible */
8615 }
8616 else
8617 {
8621 }
8622 }
8623 else
8625 }
8626
8627 PQclear(res);
8628
8629 destroyPQExpBuffer(query);
8630}
8631
8632/*
8633 * getTriggers
8634 * get information about every trigger on a dumpable table
8635 *
8636 * Note: trigger data is not returned directly to the caller, but it
8637 * does get entered into the DumpableObject tables.
8638 */
8639void
8641{
8644 PGresult *res;
8645 int ntups;
8649 i_oid,
8650 i_tgrelid,
8651 i_tgname,
8652 i_tgenabled,
8653 i_tgispartition,
8654 i_tgdef;
8655
8656 /*
8657 * We want to perform just one query against pg_trigger. However, we
8658 * mustn't try to select every row of the catalog and then sort it out on
8659 * the client side, because some of the server-side functions we need
8660 * would be unsafe to apply to tables we don't have lock on. Hence, we
8661 * build an array of the OIDs of tables we care about (and now have lock
8662 * on!), and use a WHERE clause to constrain which rows are selected.
8663 */
8666 {
8668
8671 continue;
8672
8673 /* OK, we need info for this table */
8677 }
8679
8681 {
8682 /*
8683 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8684 * result in non-forward-compatible dumps of WHEN clauses due to
8685 * under-parenthesization.
8686 *
8687 * NB: We need to see partition triggers in case the tgenabled flag
8688 * has been changed from the parent.
8689 */
8690 appendPQExpBuffer(query,
8691 "SELECT t.tgrelid, t.tgname, "
8692 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8693 "t.tgenabled, t.tableoid, t.oid, "
8694 "t.tgparentid <> 0 AS tgispartition\n"
8695 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8696 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8697 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8698 "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
8699 "OR t.tgenabled != u.tgenabled) "
8700 "ORDER BY t.tgrelid, t.tgname",
8701 tbloids->data);
8702 }
8704 {
8705 /*
8706 * NB: think not to use pretty=true in pg_get_triggerdef. It could
8707 * result in non-forward-compatible dumps of WHEN clauses due to
8708 * under-parenthesization.
8709 *
8710 * NB: We need to see tgisinternal triggers in partitions, in case the
8711 * tgenabled flag has been changed from the parent.
8712 */
8713 appendPQExpBuffer(query,
8714 "SELECT t.tgrelid, t.tgname, "
8715 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8716 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition\n"
8717 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8718 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8719 "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
8720 "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
8721 "ORDER BY t.tgrelid, t.tgname",
8722 tbloids->data);
8723 }
8725 {
8726 /*
8727 * NB: We need to see tgisinternal triggers in partitions, in case the
8728 * tgenabled flag has been changed from the parent. No tgparentid in
8729 * version 11-12, so we have to match them via pg_depend.
8730 *
8731 * See above about pretty=true in pg_get_triggerdef.
8732 */
8733 appendPQExpBuffer(query,
8734 "SELECT t.tgrelid, t.tgname, "
8735 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8736 "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
8737 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8738 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8739 "LEFT JOIN pg_catalog.pg_depend AS d ON "
8740 " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8741 " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
8742 " d.objid = t.oid "
8743 "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
8744 "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
8745 "ORDER BY t.tgrelid, t.tgname",
8746 tbloids->data);
8747 }
8748 else
8749 {
8750 /* See above about pretty=true in pg_get_triggerdef */
8751 appendPQExpBuffer(query,
8752 "SELECT t.tgrelid, t.tgname, "
8753 "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
8754 "t.tgenabled, false as tgispartition, "
8755 "t.tableoid, t.oid "
8756 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
8757 "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
8758 "WHERE NOT tgisinternal "
8759 "ORDER BY t.tgrelid, t.tgname",
8760 tbloids->data);
8761 }
8762
8764
8765 ntups = PQntuples(res);
8766
8774
8776
8777 /*
8778 * Outer loop iterates once per table, not once per row. Incrementing of
8779 * j is handled by the inner loop.
8780 */
8781 curtblindx = -1;
8783 {
8787
8788 /* Count rows for this table */
8791 break;
8792
8793 /*
8794 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
8795 * order.
8796 */
8798 {
8801 break;
8802 }
8805
8806 /* Save data for this table */
8809
8811 {
8822 }
8823 }
8824
8825 PQclear(res);
8826
8827 destroyPQExpBuffer(query);
8829}
8830
8831/*
8832 * getEventTriggers
8833 * get information about event triggers
8834 */
8835void
8837{
8839 PQExpBuffer query;
8840 PGresult *res;
8843 i_oid,
8844 i_evtname,
8845 i_evtevent,
8846 i_evtowner,
8847 i_evttags,
8848 i_evtfname,
8849 i_evtenabled;
8850 int ntups;
8851
8852 query = createPQExpBuffer();
8853
8854 appendPQExpBufferStr(query,
8855 "SELECT e.tableoid, e.oid, evtname, evtenabled, "
8856 "evtevent, evtowner, "
8857 "array_to_string(array("
8858 "select quote_literal(x) "
8859 " from unnest(evttags) as t(x)), ', ') as evttags, "
8860 "e.evtfoid::regproc as evtfname "
8861 "FROM pg_event_trigger e "
8862 "ORDER BY e.oid");
8863
8865
8866 ntups = PQntuples(res);
8867
8869
8878
8880 {
8892
8893 /* Decide whether we want to dump it */
8895 }
8896
8897 PQclear(res);
8898
8899 destroyPQExpBuffer(query);
8900}
8901
8902/*
8903 * getProcLangs
8904 * get basic information about every procedural language in the system
8905 *
8906 * NB: this must run after getFuncs() because we assume we can do
8907 * findFuncByOid().
8908 */
8909void
8911{
8912 PGresult *res;
8913 int ntups;
8927
8929 "lanname, lanpltrusted, lanplcallfoid, "
8930 "laninline, lanvalidator, "
8931 "lanacl, "
8932 "acldefault('l', lanowner) AS acldefault, "
8933 "lanowner "
8934 "FROM pg_language "
8935 "WHERE lanispl "
8936 "ORDER BY oid");
8937
8939
8940 ntups = PQntuples(res);
8941
8943
8954
8956 {
8961
8972
8973 /* Decide whether we want to dump it */
8975
8976 /* Mark whether language has an ACL */
8979 }
8980
8981 PQclear(res);
8982
8983 destroyPQExpBuffer(query);
8984}
8985
8986/*
8987 * getCasts
8988 * get basic information about most casts in the system
8989 *
8990 * Skip casts from a range to its multirange, since we'll create those
8991 * automatically.
8992 */
8993void
8995{
8996 PGresult *res;
8997 int ntups;
9008
9010 {
9012 "castsource, casttarget, castfunc, castcontext, "
9013 "castmethod "
9014 "FROM pg_cast c "
9015 "WHERE NOT EXISTS ( "
9016 "SELECT 1 FROM pg_range r "
9017 "WHERE c.castsource = r.rngtypid "
9018 "AND c.casttarget = r.rngmultitypid "
9019 ") "
9020 "ORDER BY 3,4");
9021 }
9022 else
9023 {
9025 "castsource, casttarget, castfunc, castcontext, "
9026 "castmethod "
9027 "FROM pg_cast ORDER BY 3,4");
9028 }
9029
9031
9032 ntups = PQntuples(res);
9033
9035
9043
9045 {
9049
9059
9060 /*
9061 * Try to name cast as concatenation of typnames. This is only used
9062 * for purposes of sorting. If we fail to find either type, the name
9063 * will be an empty string.
9064 */
9072
9073 /* Decide whether we want to dump it */
9075 }
9076
9077 PQclear(res);
9078
9079 destroyPQExpBuffer(query);
9080}
9081
9082static char *
9084{
9085 PQExpBuffer query;
9086 PGresult *res;
9088
9089 query = createPQExpBuffer();
9093 destroyPQExpBuffer(query);
9094 PQclear(res);
9095
9097}
9098
9099/*
9100 * getTransforms
9101 * get basic information about every transform in the system
9102 */
9103void
9105{
9106 PGresult *res;
9107 int ntups;
9109 PQExpBuffer query;
9117
9118 query = createPQExpBuffer();
9119
9121 "trftype, trflang, trffromsql::oid, trftosql::oid "
9122 "FROM pg_transform "
9123 "ORDER BY 3,4");
9124
9126
9127 ntups = PQntuples(res);
9128
9130
9137
9139 {
9143
9152
9153 /*
9154 * Try to name transform as concatenation of type and language name.
9155 * This is only used for purposes of sorting. If we fail to find
9156 * either, the name will be an empty string.
9157 */
9166
9167 /* Decide whether we want to dump it */
9169 }
9170
9171 PQclear(res);
9172
9173 destroyPQExpBuffer(query);
9174}
9175
9176/*
9177 * getTableAttrs -
9178 * for each interesting table, read info about its attributes
9179 * (names, types, default values, CHECK constraints, etc)
9180 *
9181 * modifies tblinfo
9182 */
9183void
9185{
9191 PGresult *res;
9192 int ntups;
9218
9219 /*
9220 * We want to perform just one query against pg_attribute, and then just
9221 * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
9222 * (for CHECK constraints and for NOT NULL constraints). However, we
9223 * mustn't try to select every row of those catalogs and then sort it out
9224 * on the client side, because some of the server-side functions we need
9225 * would be unsafe to apply to tables we don't have lock on. Hence, we
9226 * build an array of the OIDs of tables we care about (and now have lock
9227 * on!), and use a WHERE clause to constrain which rows are selected.
9228 */
9232 {
9234
9235 /* Don't bother to collect info for sequences */
9237 continue;
9238
9239 /*
9240 * Don't bother with uninteresting tables, either. For binary
9241 * upgrades, this is bypassed for pg_largeobject_metadata and
9242 * pg_shdepend so that the columns names are collected for the
9243 * corresponding COPY commands. Restoring the data for those catalogs
9244 * is faster than restoring the equivalent set of large object
9245 * commands.
9246 */
9248 !(fout->dopt->binary_upgrade &&
9251 continue;
9252
9253 /* OK, we need info for this table */
9257
9259 {
9260 /* Also make a list of the ones with check constraints */
9264 }
9265 }
9268
9269 /*
9270 * Find all the user attributes and their types.
9271 *
9272 * Since we only want to dump COLLATE clauses for attributes whose
9273 * collation is different from their type's default, we use a CASE here to
9274 * suppress uninteresting attcollations cheaply.
9275 */
9276 appendPQExpBufferStr(q,
9277 "SELECT\n"
9278 "a.attrelid,\n"
9279 "a.attnum,\n"
9280 "a.attname,\n"
9281 "a.attstattarget,\n"
9282 "a.attstorage,\n"
9283 "t.typstorage,\n"
9284 "a.atthasdef,\n"
9285 "a.attisdropped,\n"
9286 "a.attlen,\n"
9287 "a.attalign,\n"
9288 "a.attislocal,\n"
9289 "pg_catalog.format_type(t.oid, a.atttypmod) AS atttypname,\n"
9290 "array_to_string(a.attoptions, ', ') AS attoptions,\n"
9291 "CASE WHEN a.attcollation <> t.typcollation "
9292 "THEN a.attcollation ELSE 0 END AS attcollation,\n"
9293 "pg_catalog.array_to_string(ARRAY("
9294 "SELECT pg_catalog.quote_ident(option_name) || "
9295 "' ' || pg_catalog.quote_literal(option_value) "
9296 "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
9297 "ORDER BY option_name"
9298 "), E',\n ') AS attfdwoptions,\n");
9299
9300 /*
9301 * Find out any NOT NULL markings for each column. In 18 and up we read
9302 * pg_constraint to obtain the constraint name, and for valid constraints
9303 * also pg_description to obtain its comment. notnull_noinherit is set
9304 * according to the NO INHERIT property. For versions prior to 18, we
9305 * store an empty string as the name when a constraint is marked as
9306 * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
9307 * without a name); also, such cases are never NO INHERIT.
9308 *
9309 * For invalid constraints, we need to store their OIDs for processing
9310 * elsewhere, so we bring the pg_constraint.oid value when the constraint
9311 * is invalid, and NULL otherwise. Their comments are handled not here
9312 * but by collectComments, because they're their own dumpable object.
9313 *
9314 * We track in notnull_islocal whether the constraint was defined directly
9315 * in this table or via an ancestor, for binary upgrade. flagInhAttrs
9316 * might modify this later.
9317 */
9319 appendPQExpBufferStr(q,
9320 "co.conname AS notnull_name,\n"
9321 "CASE WHEN co.convalidated THEN pt.description"
9322 " ELSE NULL END AS notnull_comment,\n"
9323 "CASE WHEN NOT co.convalidated THEN co.oid "
9324 "ELSE NULL END AS notnull_invalidoid,\n"
9325 "co.connoinherit AS notnull_noinherit,\n"
9326 "co.conislocal AS notnull_islocal,\n");
9327 else
9328 appendPQExpBufferStr(q,
9329 "CASE WHEN a.attnotnull THEN '' ELSE NULL END AS notnull_name,\n"
9330 "NULL AS notnull_comment,\n"
9331 "NULL AS notnull_invalidoid,\n"
9332 "false AS notnull_noinherit,\n"
9333 "CASE WHEN a.attislocal THEN true\n"
9334 " WHEN a.attnotnull AND NOT a.attislocal THEN true\n"
9335 " ELSE false\n"
9336 "END AS notnull_islocal,\n");
9337
9339 appendPQExpBufferStr(q,
9340 "a.attcompression AS attcompression,\n");
9341 else
9342 appendPQExpBufferStr(q,
9343 "'' AS attcompression,\n");
9344
9345 appendPQExpBufferStr(q,
9346 "a.attidentity,\n");
9347
9349 appendPQExpBufferStr(q,
9350 "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
9351 "THEN a.attmissingval ELSE null END AS attmissingval,\n");
9352 else
9353 appendPQExpBufferStr(q,
9354 "NULL AS attmissingval,\n");
9355
9357 appendPQExpBufferStr(q,
9358 "a.attgenerated\n");
9359 else
9360 appendPQExpBufferStr(q,
9361 "'' AS attgenerated\n");
9362
9363 /* need left join to pg_type to not fail on dropped columns ... */
9364 appendPQExpBuffer(q,
9365 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9366 "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
9367 "LEFT JOIN pg_catalog.pg_type t "
9368 "ON (a.atttypid = t.oid)\n",
9369 tbloids->data);
9370
9371 /*
9372 * In versions 18 and up, we need pg_constraint for explicit NOT NULL
9373 * entries and pg_description to get their comments.
9374 */
9376 appendPQExpBufferStr(q,
9377 " LEFT JOIN pg_catalog.pg_constraint co ON "
9378 "(a.attrelid = co.conrelid\n"
9379 " AND co.contype = 'n' AND "
9380 "co.conkey = array[a.attnum])\n"
9381 " LEFT JOIN pg_catalog.pg_description pt ON "
9382 "(pt.classoid = co.tableoid AND pt.objoid = co.oid)\n");
9383
9384 appendPQExpBufferStr(q,
9385 "WHERE a.attnum > 0::pg_catalog.int2\n");
9386
9387 /*
9388 * For binary upgrades from <v12, be sure to pick up
9389 * pg_largeobject_metadata's oid column.
9390 */
9392 appendPQExpBufferStr(q,
9393 "OR (a.attnum = -2::pg_catalog.int2 AND src.tbloid = "
9395
9396 appendPQExpBufferStr(q,
9397 "ORDER BY a.attrelid, a.attnum");
9398
9400
9401 ntups = PQntuples(res);
9402
9427
9428 /* Within the next loop, we'll accumulate OIDs of tables with defaults */
9431
9432 /*
9433 * Outer loop iterates once per table, not once per row. Incrementing of
9434 * r is handled by the inner loop.
9435 */
9436 curtblindx = -1;
9437 for (int r = 0; r < ntups;)
9438 {
9441 int numatts;
9443
9444 /* Count rows for this table */
9445 for (numatts = 1; numatts < ntups - r; numatts++)
9447 break;
9448
9449 /*
9450 * Locate the associated TableInfo; we rely on tblinfo[] being in OID
9451 * order.
9452 */
9454 {
9457 break;
9458 }
9461 /* cross-check that we only got requested tables */
9463 (!tbinfo->interesting &&
9464 !(fout->dopt->binary_upgrade &&
9468 tbinfo->dobj.name);
9469
9470 /* Save data for this table */
9471 tbinfo->numatts = numatts;
9495
9497 {
9502 tbinfo->dobj.name);
9507 else
9513 tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
9518
9519 /* Handle not-null constraint name and flags */
9522 i_notnull_name,
9523 i_notnull_comment,
9524 i_notnull_invalidoid,
9525 i_notnull_noinherit,
9526 i_notnull_islocal,
9527 &invalidnotnulloids);
9528
9539 }
9540
9542 {
9543 /* Collect OIDs of interesting tables that have defaults */
9547 }
9548 }
9549
9550 /* If invalidnotnulloids has any data, finalize it */
9553
9554 PQclear(res);
9555
9556 /*
9557 * Now get info about column defaults. This is skipped for a data-only
9558 * dump, as it is only needed for table schemas.
9559 */
9561 {
9562 AttrDefInfo *attrdefs;
9565
9567
9569
9571 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc\n"
9572 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9573 "JOIN pg_catalog.pg_attrdef a ON (src.tbloid = a.adrelid)\n"
9574 "ORDER BY a.adrelid, a.adnum",
9575 tbloids->data);
9576
9578
9581
9582 curtblindx = -1;
9584 {
9590
9591 /*
9592 * Locate the associated TableInfo; we rely on tblinfo[] being in
9593 * OID order.
9594 */
9596 {
9598 {
9601 break;
9602 }
9605 }
9606
9609 adnum, tbinfo->dobj.name);
9610
9611 /*
9612 * dropped columns shouldn't have defaults, but just in case,
9613 * ignore 'em
9614 */
9616 continue;
9617
9625
9628
9630
9631 /*
9632 * Figure out whether the default/generation expression should be
9633 * dumped as part of the main CREATE TABLE (or similar) command or
9634 * as a separate ALTER TABLE (or similar) command. The preference
9635 * is to put it into the CREATE command, but in some cases that's
9636 * not possible.
9637 */
9639 {
9640 /*
9641 * Column generation expressions cannot be dumped separately,
9642 * because there is no syntax for it. By setting separate to
9643 * false here we prevent the "default" from being processed as
9644 * its own dumpable object. Later, flagInhAttrs() will mark
9645 * it as not to be dumped at all, if possible (that is, if it
9646 * can be inherited from a parent).
9647 */
9649 }
9651 {
9652 /*
9653 * Defaults on a VIEW must always be dumped as separate ALTER
9654 * TABLE commands.
9655 */
9657 }
9659 {
9660 /* column will be suppressed, print default separately */
9662 }
9663 else
9664 {
9666 }
9667
9669 {
9670 /*
9671 * Mark the default as needing to appear before the table, so
9672 * that any dependencies it has must be emitted before the
9673 * CREATE TABLE. If this is not possible, we'll change to
9674 * "separate" mode while sorting dependencies.
9675 */
9677 attrdefs[j].dobj.dumpId);
9678 }
9679
9681 }
9682
9683 PQclear(res);
9684 }
9685
9686 /*
9687 * Get info about NOT NULL NOT VALID constraints. This is skipped for a
9688 * data-only dump, as it is only needed for table schemas.
9689 */
9691 {
9700
9702
9703 resetPQExpBuffer(q);
9704 appendPQExpBuffer(q,
9705 "SELECT c.tableoid, c.oid, conrelid, conname, "
9706 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9707 "conislocal, convalidated "
9708 "FROM unnest('%s'::pg_catalog.oid[]) AS src(conoid)\n"
9709 "JOIN pg_catalog.pg_constraint c ON (src.conoid = c.oid)\n"
9710 "ORDER BY c.conrelid, c.conname",
9711 invalidnotnulloids->data);
9712
9714
9717
9724
9725 /* As above, this loop iterates once per table, not once per row */
9726 curtblindx = -1;
9728 {
9732
9733 /* Count rows for this table */
9736 break;
9737
9738 /*
9739 * Locate the associated TableInfo; we rely on tblinfo[] being in
9740 * OID order.
9741 */
9743 {
9746 break;
9747 }
9750
9752 {
9768
9769 /*
9770 * All invalid not-null constraints must be dumped separately,
9771 * because CREATE TABLE would not create them as invalid, and
9772 * also because they must be created after potentially
9773 * violating data has been loaded.
9774 */
9776
9778 }
9779 }
9780 PQclear(res);
9781 }
9782
9783 /*
9784 * Get info about table CHECK constraints. This is skipped for a
9785 * data-only dump, as it is only needed for table schemas.
9786 */
9788 {
9798
9800
9801 resetPQExpBuffer(q);
9802 appendPQExpBuffer(q,
9803 "SELECT c.tableoid, c.oid, conrelid, conname, "
9804 "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
9805 "conislocal, convalidated "
9806 "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
9807 "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
9808 "WHERE contype = 'c' "
9809 "ORDER BY c.conrelid, c.conname",
9810 checkoids->data);
9811
9813
9816
9824
9825 /* As above, this loop iterates once per table, not once per row */
9826 curtblindx = -1;
9828 {
9832
9833 /* Count rows for this table */
9836 break;
9837
9838 /*
9839 * Locate the associated TableInfo; we rely on tblinfo[] being in
9840 * OID order.
9841 */
9843 {
9846 break;
9847 }
9850
9852 {
9854 "expected %d check constraints on table \"%s\" but found %d",
9855 tbinfo->ncheck),
9858 exit_nicely(1);
9859 }
9860
9862
9864 {
9866
9882
9883 /*
9884 * An unvalidated constraint needs to be dumped separately, so
9885 * that potentially-violating existing data is loaded before
9886 * the constraint.
9887 */
9889
9891
9892 /*
9893 * Mark the constraint as needing to appear before the table
9894 * --- this is so that any other dependencies of the
9895 * constraint will be emitted before we try to create the
9896 * table. If the constraint is to be dumped separately, it
9897 * will be dumped after data is loaded anyway, so don't do it.
9898 * (There's an automatic dependency in the opposite direction
9899 * anyway, so don't need to add one manually here.)
9900 */
9904
9905 /*
9906 * We will detect later whether the constraint must be split
9907 * out from the table definition.
9908 */
9909 }
9910 }
9911
9912 PQclear(res);
9913 }
9914
9915 destroyPQExpBuffer(q);
9918}
9919
9920/*
9921 * Based on the getTableAttrs query's row corresponding to one column, set
9922 * the name and flags to handle a not-null constraint for that column in
9923 * the tbinfo struct.
9924 *
9925 * Result row 'r' is for tbinfo's attribute 'j'.
9926 *
9927 * There are four possibilities:
9928 * 1) the column has no not-null constraints. In that case, ->notnull_constrs
9929 * (the constraint name) remains NULL.
9930 * 2) The column has a constraint with no name (this is the case when
9931 * constraints come from pre-18 servers). In this case, ->notnull_constrs
9932 * is set to the empty string; dumpTableSchema will print just "NOT NULL".
9933 * 3) The column has an invalid not-null constraint. This must be treated
9934 * as a separate object (because it must be created after the table data
9935 * is loaded). So we add its OID to invalidnotnulloids for processing
9936 * elsewhere and do nothing further with it here. We distinguish this
9937 * case because the "notnull_invalidoid" column has been set to a non-NULL
9938 * value, which is the constraint OID. Valid constraints have a null OID.
9939 * 4) The column has a constraint with a known name; in that case
9940 * notnull_constrs carries that name and dumpTableSchema will print
9941 * "CONSTRAINT the_name NOT NULL". However, if the name is the default
9942 * (table_column_not_null) and there's no comment on the constraint,
9943 * there's no need to print that name in the dump, so notnull_constrs
9944 * is set to the empty string and it behaves as case 2.
9945 *
9946 * In a child table that inherits from a parent already containing NOT NULL
9947 * constraints and the columns in the child don't have their own NOT NULL
9948 * declarations, we suppress printing constraints in the child: the
9949 * constraints are acquired at the point where the child is attached to the
9950 * parent. This is tracked in ->notnull_islocal; for servers pre-18 this is
9951 * set not here but in flagInhAttrs. That flag is also used when the
9952 * constraint was validated in a child but all its parent have it as NOT
9953 * VALID.
9954 *
9955 * Any of these constraints might have the NO INHERIT bit. If so we set
9956 * ->notnull_noinh and NO INHERIT will be printed by dumpTableSchema.
9957 *
9958 * In case 4 above, the name comparison is a bit of a hack; it actually fails
9959 * to do the right thing in all but the trivial case. However, the downside
9960 * of getting it wrong is simply that the name is printed rather than
9961 * suppressed, so it's not a big deal.
9962 *
9963 * invalidnotnulloids is expected to be given as NULL; if any invalid not-null
9964 * constraints are found, it is initialized and filled with the array of
9965 * OIDs of such constraints, for later processing.
9966 */
9967static void
9976{
9978
9979 /*
9980 * If this not-null constraint is not valid, list its OID in
9981 * invalidnotnulloids and do nothing further. It'll be processed
9982 * elsewhere later.
9983 *
9984 * Because invalid not-null constraints are rare, we don't want to malloc
9985 * invalidnotnulloids until we're sure we're going it need it, which
9986 * happens here.
9987 */
9989 {
9991
9993 {
9997 }
9998 else
10000
10001 /*
10002 * Track when a parent constraint is invalid for the cases where a
10003 * child constraint has been validated independenly.
10004 */
10006
10007 /* nothing else to do */
10009 return;
10010 }
10011
10012 /*
10013 * notnull_noinh is straight from the query result. notnull_islocal also,
10014 * though flagInhAttrs may change that one later.
10015 */
10019
10020 /*
10021 * Determine a constraint name to use. If the column is not marked not-
10022 * null, we set NULL which cues ... to do nothing. An empty string says
10023 * to print an unnamed NOT NULL, and anything else is a constraint name to
10024 * use.
10025 */
10027 {
10028 /*
10029 * < 18 doesn't have not-null names, so an unnamed constraint is
10030 * sufficient.
10031 */
10034 else
10036 }
10037 else
10038 {
10041 else
10042 {
10043 /*
10044 * In binary upgrade of inheritance child tables, must have a
10045 * constraint name that we can UPDATE later; same if there's a
10046 * comment on the constraint.
10047 */
10049 !tbinfo->ispartition &&
10052 {
10055 }
10056 else
10057 {
10059
10060 /* XXX should match ChooseConstraintName better */
10066 else
10067 {
10070 }
10072 }
10073 }
10074 }
10075}
10076
10077/*
10078 * Test whether a column should be printed as part of table's CREATE TABLE.
10079 * Column number is zero-based.
10080 *
10081 * Normally this is always true, but it's false for dropped columns, as well
10082 * as those that were inherited without any local definition. (If we print
10083 * such a column it will mistakenly get pg_attribute.attislocal set to true.)
10084 * For partitions, it's always true, because we want the partitions to be
10085 * created independently and ATTACH PARTITION used afterwards.
10086 *
10087 * In binary_upgrade mode, we must print all columns and fix the attislocal/
10088 * attisdropped state later, so as to keep control of the physical column
10089 * order.
10090 *
10091 * This function exists because there are scattered nonobvious places that
10092 * must be kept in sync with this decision.
10093 */
10094bool
10096{
10098 return true;
10100 return false;
10102}
10103
10104
10105/*
10106 * getTSParsers:
10107 * get information about all text search parsers in the system catalogs
10108 */
10109void
10111{
10112 PGresult *res;
10113 int ntups;
10115 PQExpBuffer query;
10126
10127 query = createPQExpBuffer();
10128
10129 /*
10130 * find all text search objects, including builtin ones; we filter out
10131 * system-defined objects at dump-out time.
10132 */
10133
10135 "prsstart::oid, prstoken::oid, "
10136 "prsend::oid, prsheadline::oid, prslextype::oid "
10137 "FROM pg_ts_parser");
10138
10140
10141 ntups = PQntuples(res);
10142
10144
10154
10156 {
10169
10170 /* Decide whether we want to dump it */
10172 }
10173
10174 PQclear(res);
10175
10176 destroyPQExpBuffer(query);
10177}
10178
10179/*
10180 * getTSDictionaries:
10181 * get information about all text search dictionaries in the system catalogs
10182 */
10183void
10185{
10186 PGresult *res;
10187 int ntups;
10189 PQExpBuffer query;
10198
10199 query = createPQExpBuffer();
10200
10202 "dictnamespace, dictowner, "
10203 "dicttemplate, dictinitoption "
10204 "FROM pg_ts_dict");
10205
10207
10208 ntups = PQntuples(res);
10209
10211
10219
10221 {
10233 else
10235
10236 /* Decide whether we want to dump it */
10238 }
10239
10240 PQclear(res);
10241
10242 destroyPQExpBuffer(query);
10243}
10244
10245/*
10246 * getTSTemplates:
10247 * get information about all text search templates in the system catalogs
10248 */
10249void
10251{
10252 PGresult *res;
10253 int ntups;
10255 PQExpBuffer query;
10263
10264 query = createPQExpBuffer();
10265
10267 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
10268 "FROM pg_ts_template");
10269
10271
10272 ntups = PQntuples(res);
10273
10275
10282
10284 {
10294
10295 /* Decide whether we want to dump it */
10297 }
10298
10299 PQclear(res);
10300
10301 destroyPQExpBuffer(query);
10302}
10303
10304/*
10305 * getTSConfigurations:
10306 * get information about all text search configurations
10307 */
10308void
10310{
10311 PGresult *res;
10312 int ntups;
10314 PQExpBuffer query;
10322
10323 query = createPQExpBuffer();
10324
10326 "cfgnamespace, cfgowner, cfgparser "
10327 "FROM pg_ts_config");
10328
10330
10331 ntups = PQntuples(res);
10332
10334
10341
10343 {
10353
10354 /* Decide whether we want to dump it */
10356 }
10357
10358 PQclear(res);
10359
10360 destroyPQExpBuffer(query);
10361}
10362
10363/*
10364 * getForeignDataWrappers:
10365 * get information about all foreign-data wrappers in the system catalogs
10366 */
10367void
10369{
10370 PGresult *res;
10371 int ntups;
10373 PQExpBuffer query;
10385
10386 query = createPQExpBuffer();
10387
10389 "fdwowner, "
10390 "fdwhandler::pg_catalog.regproc, "
10391 "fdwvalidator::pg_catalog.regproc, ");
10392
10395 else
10397
10398 appendPQExpBufferStr(query,
10399 "fdwacl, "
10400 "acldefault('F', fdwowner) AS acldefault, "
10401 "array_to_string(ARRAY("
10402 "SELECT quote_ident(option_name) || ' ' || "
10403 "quote_literal(option_value) "
10404 "FROM pg_options_to_table(fdwoptions) "
10405 "ORDER BY option_name"
10406 "), E',\n ') AS fdwoptions "
10407 "FROM pg_foreign_data_wrapper");
10408
10410
10411 ntups = PQntuples(res);
10412
10414
10425
10427 {
10443
10444 /* Decide whether we want to dump it */
10446
10447 /* Mark whether FDW has an ACL */
10450 }
10451
10452 PQclear(res);
10453
10454 destroyPQExpBuffer(query);
10455}
10456
10457/*
10458 * getForeignServers:
10459 * get information about all foreign servers in the system catalogs
10460 */
10461void
10463{
10464 PGresult *res;
10465 int ntups;
10467 PQExpBuffer query;
10479
10480 query = createPQExpBuffer();
10481
10483 "srvowner, "
10484 "srvfdw, srvtype, srvversion, srvacl, "
10485 "acldefault('S', srvowner) AS acldefault, "
10486 "array_to_string(ARRAY("
10487 "SELECT quote_ident(option_name) || ' ' || "
10488 "quote_literal(option_value) "
10489 "FROM pg_options_to_table(srvoptions) "
10490 "ORDER BY option_name"
10491 "), E',\n ') AS srvoptions "
10492 "FROM pg_foreign_server");
10493
10495
10496 ntups = PQntuples(res);
10497
10499
10510
10512 {
10528
10529 /* Decide whether we want to dump it */
10531
10532 /* Servers have user mappings */
10534
10535 /* Mark whether server has an ACL */
10538 }
10539
10540 PQclear(res);
10541
10542 destroyPQExpBuffer(query);
10543}
10544
10545/*
10546 * getDefaultACLs:
10547 * get information about all default ACL information in the system catalogs
10548 */
10549void
10551{
10554 PQExpBuffer query;
10555 PGresult *res;
10564 ntups;
10565
10566 query = createPQExpBuffer();
10567
10568 /*
10569 * Global entries (with defaclnamespace=0) replace the hard-wired default
10570 * ACL for their object type. We should dump them as deltas from the
10571 * default ACL, since that will be used as a starting point for
10572 * interpreting the ALTER DEFAULT PRIVILEGES commands. On the other hand,
10573 * non-global entries can only add privileges not revoke them. We must
10574 * dump those as-is (i.e., as deltas from an empty ACL).
10575 *
10576 * We can use defaclobjtype as the object type for acldefault(), except
10577 * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
10578 * 's'.
10579 */
10580 appendPQExpBufferStr(query,
10581 "SELECT oid, tableoid, "
10582 "defaclrole, "
10583 "defaclnamespace, "
10584 "defaclobjtype, "
10585 "defaclacl, "
10586 "CASE WHEN defaclnamespace = 0 THEN "
10587 "acldefault(CASE WHEN defaclobjtype = 'S' "
10588 "THEN 's'::\"char\" ELSE defaclobjtype END, "
10589 "defaclrole) ELSE '{}' END AS acldefault "
10590 "FROM pg_default_acl");
10591
10593
10594 ntups = PQntuples(res);
10595
10597
10605
10607 {
10609
10614 /* cheesy ... is it worth coming up with a better object name? */
10616
10619 else
10621
10628
10629 /* Default ACLs are ACLs, of course */
10631
10632 /* Decide whether we want to dump it */
10634 }
10635
10636 PQclear(res);
10637
10638 destroyPQExpBuffer(query);
10639}
10640
10641/*
10642 * getRoleName -- look up the name of a role, given its OID
10643 *
10644 * In current usage, we don't expect failures, so error out for a bad OID.
10645 */
10646static const char *
10648{
10650
10651 /*
10652 * Do binary search to find the appropriate item.
10653 */
10655 {
10658
10659 while (low <= high)
10660 {
10662
10664 high = middle - 1;
10666 low = middle + 1;
10667 else
10669 }
10670 }
10671
10674}
10675
10676/*
10677 * collectRoleNames --
10678 *
10679 * Construct a table of all known roles.
10680 * The table is sorted by OID for speed in lookup.
10681 */
10682static void
10684{
10685 PGresult *res;
10686 const char *query;
10688
10689 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10690
10692
10694
10696
10698 {
10701 }
10702
10703 PQclear(res);
10704}
10705
10706/*
10707 * getAdditionalACLs
10708 *
10709 * We have now created all the DumpableObjects, and collected the ACL data
10710 * that appears in the directly-associated catalog entries. However, there's
10711 * more ACL-related info to collect. If any of a table's columns have ACLs,
10712 * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
10713 * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
10714 * Also, in versions having the pg_init_privs catalog, read that and load the
10715 * information into the relevant DumpableObjects.
10716 */
10717static void
10719{
10721 PGresult *res;
10722 int ntups,
10723 i;
10724
10725 /* Check for per-column ACLs */
10726 appendPQExpBufferStr(query,
10727 "SELECT DISTINCT attrelid FROM pg_attribute "
10728 "WHERE attacl IS NOT NULL");
10729
10731
10732 ntups = PQntuples(res);
10734 {
10736 TableInfo *tblinfo;
10737
10738 tblinfo = findTableByOid(relid);
10739 /* OK to ignore tables we haven't got a DumpableObject for */
10740 if (tblinfo)
10741 {
10744 }
10745 }
10746 PQclear(res);
10747
10748 /* Fetch initial-privileges data */
10749 printfPQExpBuffer(query,
10750 "SELECT objoid, classoid, objsubid, privtype, initprivs "
10751 "FROM pg_init_privs");
10752
10754
10755 ntups = PQntuples(res);
10757 {
10763 CatalogId objId;
10764 DumpableObject *dobj;
10765
10766 objId.tableoid = classoid;
10767 objId.oid = objoid;
10768 dobj = findObjectByCatalogId(objId);
10769 /* OK to ignore entries we haven't got a DumpableObject for */
10770 if (dobj)
10771 {
10772 /* Cope with sub-object initprivs */
10773 if (objsubid != 0)
10774 {
10776 {
10777 /* For a column initprivs, set the table's ACL flags */
10780 }
10781 else
10783 classoid, objoid, objsubid);
10784 continue;
10785 }
10786
10787 /*
10788 * We ignore any pg_init_privs.initprivs entry for the public
10789 * schema, as explained in getNamespaces().
10790 */
10793 continue;
10794
10795 /* Else it had better be of a type we think has ACLs */
10804 {
10806
10809 }
10810 else
10812 classoid, objoid, objsubid);
10813 }
10814 }
10815 PQclear(res);
10816
10817 destroyPQExpBuffer(query);
10818}
10819
10820/*
10821 * dumpCommentExtended --
10822 *
10823 * This routine is used to dump any comments associated with the
10824 * object handed to this routine. The routine takes the object type
10825 * and object name (ready to print, except for schema decoration), plus
10826 * the namespace and owner of the object (for labeling the ArchiveEntry),
10827 * plus catalog ID and subid which are the lookup key for pg_description,
10828 * plus the dump ID for the object (for setting a dependency).
10829 * If a matching pg_description entry is found, it is dumped.
10830 *
10831 * Note: in some cases, such as comments for triggers and rules, the "type"
10832 * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
10833 * but it doesn't seem worth complicating the API for all callers to make
10834 * it cleaner.
10835 *
10836 * Note: although this routine takes a dumpId for dependency purposes,
10837 * that purpose is just to mark the dependency in the emitted dump file
10838 * for possible future use by pg_restore. We do NOT use it for determining
10839 * ordering of the comment in the dump file, because this routine is called
10840 * after dependency sorting occurs. This routine should be called just after
10841 * calling ArchiveEntry() for the specified object.
10842 */
10843static void
10849{
10853
10854 /* do nothing, if --no-comments is supplied */
10856 return;
10857
10858 /* Comments are schema not data ... except LO comments are data */
10860 {
10862 return;
10863 }
10864 else
10865 {
10866 /* We do dump LO comments in binary-upgrade mode */
10868 return;
10869 }
10870
10871 /* Search for comments associated with catalogId, using table */
10873 &comments);
10874
10875 /* Is there one matching the subid? */
10877 {
10879 break;
10880 comments++;
10881 ncomments--;
10882 }
10883
10885 {
10887
10888 /*
10889 * initdb creates this object with a comment. Skip dumping the
10890 * initdb-provided comment, which would complicate matters for
10891 * non-superuser use of pg_dump. When the DBA has removed initdb's
10892 * comment, replicate that.
10893 */
10895 {
10897 ncomments = 1;
10898 }
10900 ncomments = 0;
10901 }
10902
10903 /* If a comment exists, build COMMENT ON statement */
10905 {
10908
10910 if (namespace && *namespace)
10915
10917
10918 /*
10919 * We mark comments as SECTION_NONE because they really belong in the
10920 * same section as their parent, whether that is pre-data or
10921 * post-data.
10922 */
10925 .namespace = namespace,
10926 .owner = owner,
10927 .description = "COMMENT",
10928 .section = SECTION_NONE,
10929 .createStmt = query->data,
10930 .deps = &dumpId,
10931 .nDeps = 1));
10932
10933 destroyPQExpBuffer(query);
10934 destroyPQExpBuffer(tag);
10935 }
10936}
10937
10938/*
10939 * dumpComment --
10940 *
10941 * Typical simplification of the above function.
10942 */
10943static inline void
10948{
10950 catalogId, subid, dumpId, NULL);
10951}
10952
10953/*
10954 * appendNamedArgument --
10955 *
10956 * Convenience routine for constructing parameters of the form:
10957 * 'paraname', 'value'::type
10958 */
10959static void
10962{
10964
10967
10970}
10971
10972/*
10973 * fetchAttributeStats --
10974 *
10975 * Fetch next batch of attribute statistics for dumpRelationStats_dumper().
10976 */
10979{
10984 int count = 0;
10989
10990 /* If we're just starting, set our TOC pointer. */
10991 if (!te)
10993
10994 /*
10995 * We can't easily avoid a second TOC scan for the tar format because it
10996 * writes restore.sql separately, which means we must execute the queries
10997 * twice. This feels risky, but there is no known reason it should
10998 * generate different output than the first pass. Even if it does, the
10999 * worst-case scenario is that restore.sql might have different statistics
11000 * data than the archive.
11001 */
11003 {
11006 }
11007
11011
11012 /*
11013 * Scan the TOC for the next set of relevant stats entries. We assume
11014 * that statistics are dumped in the order they are listed in the TOC.
11015 * This is perhaps not the sturdiest assumption, so we verify it matches
11016 * reality in dumpRelationStats_dumper().
11017 */
11019 {
11022 continue;
11023
11025 {
11027 char relid[32];
11028
11030 appendPGArray(relids, relid);
11031 }
11032 else
11033 {
11036 }
11037
11038 count++;
11039 }
11040
11044
11045 /* Execute the query for the next batch of relations. */
11046 if (count > 0)
11047 {
11049
11051
11053 {
11056 }
11057 else
11058 {
11063 }
11064
11066 destroyPQExpBuffer(query);
11067 }
11068
11069 destroyPQExpBuffer(relids);
11072 return res;
11073}
11074
11075/*
11076 * dumpRelationStats_dumper --
11077 *
11078 * Generate command to import stats into the relation on the new database.
11079 * This routine is called by the Archiver when it wants the statistics to be
11080 * dumped.
11081 */
11082static char *
11084{
11087 static int rownum;
11088 PQExpBuffer query;
11109
11110 /*
11111 * fetchAttributeStats() assumes that the statistics are dumped in the
11112 * order they are listed in the TOC. We verify that here for safety.
11113 */
11116
11121
11126
11127 query = createPQExpBuffer();
11129 {
11131 appendPQExpBufferStr(query,
11132 "PREPARE getAttributeStats(pg_catalog.oid[]) AS\n");
11133 else
11134 appendPQExpBufferStr(query,
11135 "PREPARE getAttributeStats(pg_catalog.name[], pg_catalog.name[]) AS\n");
11136
11137 appendPQExpBufferStr(query,
11138 "SELECT s.schemaname, s.tablename, s.attname, s.inherited, "
11139 "s.null_frac, s.avg_width, s.n_distinct, "
11140 "s.most_common_vals, s.most_common_freqs, "
11141 "s.histogram_bounds, s.correlation, "
11142 "s.most_common_elems, s.most_common_elem_freqs, "
11143 "s.elem_count_histogram, ");
11144
11146 appendPQExpBufferStr(query,
11147 "s.range_length_histogram, "
11148 "s.range_empty_frac, "
11149 "s.range_bounds_histogram ");
11150 else
11151 appendPQExpBufferStr(query,
11152 "NULL AS range_length_histogram,"
11153 "NULL AS range_empty_frac,"
11154 "NULL AS range_bounds_histogram ");
11155
11156 /*
11157 * The results must be in the order of the relations supplied in the
11158 * parameters to ensure we remain in sync as we walk through the TOC.
11159 *
11160 * For versions before 19, the redundant filter clause on s.tablename
11161 * = ANY(...) seems sufficient to convince the planner to use
11162 * pg_class_relname_nsp_index, which avoids a full scan of pg_stats.
11163 * In newer versions, pg_stats returns the table OIDs, eliminating the
11164 * need for that hack.
11165 */
11167 appendPQExpBufferStr(query,
11168 "FROM pg_catalog.pg_stats s "
11169 "JOIN unnest($1) WITH ORDINALITY AS u (tableid, ord) "
11170 "ON s.tableid = u.tableid "
11171 "ORDER BY u.ord, s.attname, s.inherited");
11172 else
11173 appendPQExpBufferStr(query,
11174 "FROM pg_catalog.pg_stats s "
11175 "JOIN unnest($1, $2) WITH ORDINALITY AS u (schemaname, tablename, ord) "
11176 "ON s.schemaname = u.schemaname "
11177 "AND s.tablename = u.tablename "
11178 "WHERE s.tablename = ANY($2) "
11179 "ORDER BY u.ord, s.attname, s.inherited");
11180
11182
11184 resetPQExpBuffer(query);
11185 }
11186
11187 initPQExpBuffer(out);
11188
11189 /* restore relation stats */
11192 fout->remoteVersion);
11200
11201 /*
11202 * Before v14, a reltuples value of 0 was ambiguous: it could either mean
11203 * the relation is empty, or it could mean that it hadn't yet been
11204 * vacuumed or analyzed. (Newer versions use -1 for the latter case.)
11205 * This ambiguity allegedly can cause the planner to choose inefficient
11206 * plans after restoring to v18 or newer. To deal with this, let's just
11207 * set reltuples to -1 in that case.
11208 */
11211 else
11213
11215 rsinfo->relallvisible);
11216
11219
11221
11222 /* Fetch the next batch of attribute statistics if needed. */
11224 {
11225 PQclear(res);
11227 rownum = 0;
11228 }
11229
11247
11248 /* restore attribute stats */
11250 {
11252
11253 /* Stop if the next stat row in our cache isn't for this relation. */
11256 break;
11257
11260 fout->remoteVersion);
11265
11269
11270 /*
11271 * Indexes look up attname in indAttNames to derive attnum, all others
11272 * use attname directly. We must specify attnum for indexes, since
11273 * their attnames are not necessarily stable across dump/reload.
11274 */
11276 {
11279 }
11280 else
11281 {
11282 bool found = false;
11283
11285 {
11287 {
11289 i + 1);
11290 found = true;
11291 break;
11292 }
11293 }
11294
11295 if (!found)
11297 }
11298
11333 {
11343 }
11345 }
11346
11347 destroyPQExpBuffer(query);
11349}
11350
11351/*
11352 * dumpRelationStats --
11353 *
11354 * Make an ArchiveEntry for the relation statistics. The Archiver will take
11355 * care of gathering the statistics and generating the restore commands when
11356 * they are needed.
11357 */
11358static void
11360{
11362
11363 /* nothing to do if we are not dumping statistics */
11365 return;
11366
11369 .namespace = dobj->namespace->dobj.name,
11370 .description = "STATISTICS DATA",
11371 .section = rsinfo->section,
11372 .defnFn = dumpRelationStats_dumper,
11373 .defnArg = rsinfo,
11374 .deps = dobj->dependencies,
11375 .nDeps = dobj->nDeps));
11376}
11377
11378/*
11379 * dumpTableComment --
11380 *
11381 * As above, but dump comments for both the specified table (or view)
11382 * and its columns.
11383 */
11384static void
11387{
11391 PQExpBuffer query;
11392 PQExpBuffer tag;
11393
11394 /* do nothing, if --no-comments is supplied */
11396 return;
11397
11398 /* Comments are SCHEMA not data */
11400 return;
11401
11402 /* Search for comments associated with relation, using table */
11404 tbinfo->dobj.catId.oid,
11405 &comments);
11406
11407 /* If comments exist, build COMMENT ON statements */
11409 return;
11410
11411 query = createPQExpBuffer();
11412 tag = createPQExpBuffer();
11413
11415 {
11418
11419 if (objsubid == 0)
11420 {
11421 resetPQExpBuffer(tag);
11424
11425 resetPQExpBuffer(query);
11430
11433 .namespace = tbinfo->dobj.namespace->dobj.name,
11434 .owner = tbinfo->rolname,
11435 .description = "COMMENT",
11436 .section = SECTION_NONE,
11437 .createStmt = query->data,
11438 .deps = &(tbinfo->dobj.dumpId),
11439 .nDeps = 1));
11440 }
11442 {
11443 resetPQExpBuffer(tag);
11447
11448 resetPQExpBuffer(query);
11455
11458 .namespace = tbinfo->dobj.namespace->dobj.name,
11459 .owner = tbinfo->rolname,
11460 .description = "COMMENT",
11461 .section = SECTION_NONE,
11462 .createStmt = query->data,
11463 .deps = &(tbinfo->dobj.dumpId),
11464 .nDeps = 1));
11465 }
11466
11467 comments++;
11468 ncomments--;
11469 }
11470
11471 destroyPQExpBuffer(query);
11472 destroyPQExpBuffer(tag);
11473}
11474
11475/*
11476 * findComments --
11477 *
11478 * Find the comment(s), if any, associated with the given object. All the
11479 * objsubid values associated with the given classoid/objoid are found with
11480 * one search.
11481 */
11482static int
11484{
11486 CommentItem *low;
11487 CommentItem *high;
11488 int nmatch;
11489
11490 /*
11491 * Do binary search to find some item matching the object.
11492 */
11493 low = &comments[0];
11495 while (low <= high)
11496 {
11497 middle = low + (high - low) / 2;
11498
11500 high = middle - 1;
11502 low = middle + 1;
11504 high = middle - 1;
11506 low = middle + 1;
11507 else
11508 break; /* found a match */
11509 }
11510
11511 if (low > high) /* no matches */
11512 {
11514 return 0;
11515 }
11516
11517 /*
11518 * Now determine how many items match the object. The search loop
11519 * invariant still holds: only items between low and high inclusive could
11520 * match.
11521 */
11522 nmatch = 1;
11524 {
11526 objoid != middle[-1].objoid)
11527 break;
11528 middle--;
11529 nmatch++;
11530 }
11531
11533
11534 middle += nmatch;
11536 {
11538 objoid != middle->objoid)
11539 break;
11540 middle++;
11541 nmatch++;
11542 }
11543
11544 return nmatch;
11545}
11546
11547/*
11548 * collectComments --
11549 *
11550 * Construct a table of all comments available for database objects;
11551 * also set the has-comment component flag for each relevant object.
11552 *
11553 * We used to do per-object queries for the comments, but it's much faster
11554 * to pull them all over at once, and on most databases the memory cost
11555 * isn't high.
11556 *
11557 * The table is sorted by classoid/objid/objsubid for speed in lookup.
11558 */
11559static void
11561{
11562 PGresult *res;
11563 PQExpBuffer query;
11568 int ntups;
11570 DumpableObject *dobj;
11571
11572 query = createPQExpBuffer();
11573
11575 "FROM pg_catalog.pg_description "
11576 "ORDER BY classoid, objoid, objsubid");
11577
11579
11580 /* Construct lookup table containing OIDs in numeric form */
11581
11586
11587 ntups = PQntuples(res);
11588
11590 ncomments = 0;
11591 dobj = NULL;
11592
11594 {
11595 CatalogId objId;
11596 int subid;
11597
11601
11602 /* We needn't remember comments that don't match any dumpable object */
11606 dobj = findObjectByCatalogId(objId);
11608 continue;
11609
11610 /*
11611 * Comments on columns of composite types are linked to the type's
11612 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11613 * in the type's own DumpableObject.
11614 */
11617 {
11619
11623 }
11624 else
11625 dobj->components |= DUMP_COMPONENT_COMMENT;
11626
11631 ncomments++;
11632 }
11633
11634 PQclear(res);
11635 destroyPQExpBuffer(query);
11636}
11637
11638/*
11639 * dumpDumpableObject
11640 *
11641 * This routine and its subsidiaries are responsible for creating
11642 * ArchiveEntries (TOC objects) for each object to be dumped.
11643 */
11644static void
11646{
11647 /*
11648 * Clear any dump-request bits for components that don't exist for this
11649 * object. (This makes it safe to initially use DUMP_COMPONENT_ALL as the
11650 * request for every kind of object.)
11651 */
11653
11654 /* Now, short-circuit if there's nothing to be done here. */
11656 return;
11657
11659 {
11662 break;
11665 break;
11668 break;
11671 break;
11674 break;
11677 break;
11680 break;
11683 break;
11686 break;
11689 break;
11692 break;
11695 break;
11698 break;
11701 break;
11704 break;
11707 break;
11710 break;
11714 break;
11717 break;
11720 break;
11723 break;
11726 break;
11729 break;
11732 break;
11735 break;
11738 break;
11741 break;
11744 break;
11747 break;
11749 /* table rowtypes and array types are never dumped separately */
11750 break;
11753 break;
11756 break;
11759 break;
11762 break;
11765 break;
11768 break;
11771 break;
11774 break;
11777 {
11779 TocEntry *te;
11780
11784 dobj->name);
11785
11788 .owner = loinfo->rolname,
11789 .description = "BLOBS",
11790 .section = SECTION_DATA,
11791 .deps = dobj->dependencies,
11792 .nDeps = dobj->nDeps,
11793 .dumpFn = dumpLOs,
11794 .dumpArg = loinfo));
11795
11796 /*
11797 * Set the TocEntry's dataLength in case we are doing a
11798 * parallel dump and want to order dump jobs by table size.
11799 * (We need some size estimate for every TocEntry with a
11800 * DataDumper function.) We don't currently have any cheap
11801 * way to estimate the size of LOs, but fortunately it doesn't
11802 * matter too much as long as we get large batches of LOs
11803 * processed reasonably early. Assume 8K per blob.
11804 */
11806 }
11807 break;
11810 break;
11813 break;
11816 break;
11820 break;
11823 break;
11826 break;
11829 break;
11832 /* never dumped, nothing to do */
11833 break;
11834 }
11835}
11836
11837/*
11838 * dumpNamespace
11839 * writes out to fout the queries to recreate a user-defined namespace
11840 */
11841static void
11843{
11845 PQExpBuffer q;
11848
11849 /* Do nothing if not dumping schema */
11851 return;
11852
11853 q = createPQExpBuffer();
11855
11857
11859 {
11862 }
11863 else
11864 {
11865 /* see selectDumpableNamespace() */
11867 "-- *not* dropping schema, since initdb creates it\n");
11868 appendPQExpBufferStr(q,
11869 "-- *not* creating schema, since initdb creates it\n");
11870 }
11871
11875
11879 .owner = nspinfo->rolname,
11880 .description = "SCHEMA",
11881 .section = SECTION_PRE_DATA,
11882 .createStmt = q->data,
11883 .dropStmt = delq->data));
11884
11885 /* Dump Schema Comments and Security Labels */
11887 {
11889
11895 initdb_comment);
11896 }
11897
11902
11907
11909
11910 destroyPQExpBuffer(q);
11912}
11913
11914/*
11915 * dumpExtension
11916 * writes out to fout the queries to recreate an extension
11917 */
11918static void
11920{
11922 PQExpBuffer q;
11925
11926 /* Do nothing if not dumping schema */
11928 return;
11929
11930 q = createPQExpBuffer();
11932
11934
11936
11938 {
11939 /*
11940 * In a regular dump, we simply create the extension, intentionally
11941 * not specifying a version, so that the destination installation's
11942 * default version is used.
11943 *
11944 * Use of IF NOT EXISTS here is unlike our behavior for other object
11945 * types; but there are various scenarios in which it's convenient to
11946 * manually create the desired extension before restoring, so we
11947 * prefer to allow it to exist already.
11948 */
11951 }
11952 else
11953 {
11954 /*
11955 * In binary-upgrade mode, it's critical to reproduce the state of the
11956 * database exactly, so our procedure is to create an empty extension,
11957 * restore all the contained objects normally, and add them to the
11958 * extension one by one. This function performs just the first of
11959 * those steps. binary_upgrade_extension_member() takes care of
11960 * adding member objects as they're created.
11961 */
11963 int n;
11964
11965 appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
11966
11967 /*
11968 * We unconditionally create the extension, so we must drop it if it
11969 * exists. This could happen if the user deleted 'plpgsql' and then
11970 * readded it, causing its oid to be greater than g_last_builtin_oid.
11971 */
11973
11974 appendPQExpBufferStr(q,
11975 "SELECT pg_catalog.binary_upgrade_create_empty_extension(");
11983
11984 /*
11985 * Note that we're pushing extconfig (an OID array) back into
11986 * pg_extension exactly as-is. This is OK because pg_class OIDs are
11987 * preserved in binary upgrade.
11988 */
11991 else
11996 else
12000 n = 0;
12002 {
12004
12007 {
12008 if (n++ > 0)
12011 }
12012 }
12015 }
12016
12020 .description = "EXTENSION",
12021 .section = SECTION_PRE_DATA,
12022 .createStmt = q->data,
12023 .dropStmt = delq->data));
12024
12025 /* Dump Extension Comments */
12030
12032
12033 destroyPQExpBuffer(q);
12035}
12036
12037/*
12038 * dumpType
12039 * writes out to fout the queries to recreate a user-defined type
12040 */
12041static void
12043{
12045
12046 /* Do nothing if not dumping schema */
12048 return;
12049
12050 /* Dump out in proper style */
12063 else
12065 tyinfo->dobj.name);
12066}
12067
12068/*
12069 * dumpEnumType
12070 * writes out to fout the queries to recreate a user-defined enum type
12071 */
12072static void
12074{
12079 PGresult *res;
12080 int num,
12081 i;
12082 Oid enum_oid;
12088
12090 {
12091 /* Set up query for enum-specific details */
12092 appendPQExpBufferStr(query,
12093 "PREPARE dumpEnumType(pg_catalog.oid) AS\n"
12094 "SELECT oid, enumlabel "
12095 "FROM pg_catalog.pg_enum "
12096 "WHERE enumtypid = $1 "
12097 "ORDER BY enumsortorder");
12098
12100
12102 }
12103
12104 printfPQExpBuffer(query,
12105 "EXECUTE dumpEnumType('%u')",
12106 tyinfo->dobj.catId.oid);
12107
12109
12110 num = PQntuples(res);
12111
12114
12115 /*
12116 * CASCADE shouldn't be required here as for normal types since the I/O
12117 * functions are generic and do not get dropped.
12118 */
12120
12123 tyinfo->dobj.catId.oid,
12124 false, false);
12125
12127 qualtypname);
12128
12130 {
12132
12133 /* Labels with server-assigned oids */
12135 {
12141 }
12142 }
12143
12145
12147 {
12150
12151 /* Labels with dump-assigned (preserved) oids */
12153 {
12156
12159 appendPQExpBuffer(q,
12160 "SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
12161 enum_oid);
12165 }
12166 }
12167
12171 tyinfo->dobj.namespace->dobj.name);
12172
12176 .namespace = tyinfo->dobj.namespace->dobj.name,
12177 .owner = tyinfo->rolname,
12178 .description = "TYPE",
12179 .section = SECTION_PRE_DATA,
12180 .createStmt = q->data,
12181 .dropStmt = delq->data));
12182
12183 /* Dump Type Comments and Security Labels */
12188
12193
12197 tyinfo->dobj.namespace->dobj.name,
12199
12200 PQclear(res);
12201 destroyPQExpBuffer(q);
12203 destroyPQExpBuffer(query);
12206}
12207
12208/*
12209 * dumpRangeType
12210 * writes out to fout the queries to recreate a user-defined range type
12211 */
12212static void
12214{
12219 PGresult *res;
12223 char *procname;
12224
12226 {
12227 /* Set up query for range-specific details */
12228 appendPQExpBufferStr(query,
12229 "PREPARE dumpRangeType(pg_catalog.oid) AS\n");
12230
12231 appendPQExpBufferStr(query,
12232 "SELECT ");
12233
12235 appendPQExpBufferStr(query,
12236 "pg_catalog.format_type(rngmultitypid, NULL) AS rngmultitype, ");
12237 else
12238 appendPQExpBufferStr(query,
12239 "NULL AS rngmultitype, ");
12240
12241 appendPQExpBufferStr(query,
12242 "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
12243 "opc.opcname AS opcname, "
12244 "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
12245 " WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
12246 "opc.opcdefault, "
12247 "CASE WHEN rngcollation = st.typcollation THEN 0 "
12248 " ELSE rngcollation END AS collation, "
12249 "rngcanonical, rngsubdiff "
12250 "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
12251 " pg_catalog.pg_opclass opc "
12252 "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
12253 "rngtypid = $1");
12254
12256
12258 }
12259
12260 printfPQExpBuffer(query,
12261 "EXECUTE dumpRangeType('%u')",
12262 tyinfo->dobj.catId.oid);
12263
12265
12268
12269 /*
12270 * CASCADE shouldn't be required here as for normal types since the I/O
12271 * functions are generic and do not get dropped.
12272 */
12274
12277 tyinfo->dobj.catId.oid,
12278 false, true);
12279
12281 qualtypname);
12282
12285
12289
12290 /* print subtype_opclass only if not default for subtype */
12292 {
12295
12297 fmtId(nspname));
12299 }
12300
12303 {
12305
12306 if (coll)
12308 fmtQualifiedDumpable(coll));
12309 }
12310
12314
12318
12320
12324 tyinfo->dobj.namespace->dobj.name);
12325
12329 .namespace = tyinfo->dobj.namespace->dobj.name,
12330 .owner = tyinfo->rolname,
12331 .description = "TYPE",
12332 .section = SECTION_PRE_DATA,
12333 .createStmt = q->data,
12334 .dropStmt = delq->data));
12335
12336 /* Dump Type Comments and Security Labels */
12341
12346
12350 tyinfo->dobj.namespace->dobj.name,
12352
12353 PQclear(res);
12354 destroyPQExpBuffer(q);
12356 destroyPQExpBuffer(query);
12359}
12360
12361/*
12362 * dumpUndefinedType
12363 * writes out to fout the queries to recreate a !typisdefined type
12364 *
12365 * This is a shell type, but we use different terminology to distinguish
12366 * this case from where we have to emit a shell type definition to break
12367 * circular dependencies. An undefined type shouldn't ever have anything
12368 * depending on it.
12369 */
12370static void
12372{
12378
12381
12383
12386 tyinfo->dobj.catId.oid,
12387 false, false);
12388
12390 qualtypname);
12391
12395 tyinfo->dobj.namespace->dobj.name);
12396
12400 .namespace = tyinfo->dobj.namespace->dobj.name,
12401 .owner = tyinfo->rolname,
12402 .description = "TYPE",
12403 .section = SECTION_PRE_DATA,
12404 .createStmt = q->data,
12405 .dropStmt = delq->data));
12406
12407 /* Dump Type Comments and Security Labels */
12412
12417
12421 tyinfo->dobj.namespace->dobj.name,
12423
12424 destroyPQExpBuffer(q);
12428}
12429
12430/*
12431 * dumpBaseType
12432 * writes out to fout the queries to recreate a user-defined base type
12433 */
12434static void
12436{
12441 PGresult *res;
12444 char *typlen;
12446 char *typoutput;
12447 char *typreceive;
12448 char *typsend;
12452 char *typsubscript;
12461 char *typdelim;
12462 char *typbyval;
12464 char *typstorage;
12468
12470 {
12471 /* Set up query for type-specific details */
12472 appendPQExpBufferStr(query,
12473 "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
12474 "SELECT typlen, "
12475 "typinput, typoutput, typreceive, typsend, "
12476 "typreceive::pg_catalog.oid AS typreceiveoid, "
12477 "typsend::pg_catalog.oid AS typsendoid, "
12478 "typanalyze, "
12479 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
12480 "typdelim, typbyval, typalign, typstorage, "
12481 "typmodin, typmodout, "
12482 "typmodin::pg_catalog.oid AS typmodinoid, "
12483 "typmodout::pg_catalog.oid AS typmodoutoid, "
12484 "typcategory, typispreferred, "
12485 "(typcollation <> 0) AS typcollatable, "
12486 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
12487
12489 appendPQExpBufferStr(query,
12490 "typsubscript, "
12491 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
12492 else
12493 appendPQExpBufferStr(query,
12494 "'-' AS typsubscript, 0 AS typsubscriptoid ");
12495
12497 "WHERE oid = $1");
12498
12500
12502 }
12503
12504 printfPQExpBuffer(query,
12505 "EXECUTE dumpBaseType('%u')",
12506 tyinfo->dobj.catId.oid);
12507
12509
12535 {
12538 }
12539 else
12541
12544
12545 /*
12546 * The reason we include CASCADE is that the circular dependency between
12547 * the type and its I/O functions makes it impossible to drop the type any
12548 * other way.
12549 */
12551
12552 /*
12553 * We might already have a shell type, but setting pg_type_oid is
12554 * harmless, and in any case we'd better set the array type OID.
12555 */
12558 tyinfo->dobj.catId.oid,
12559 false, false);
12560
12561 appendPQExpBuffer(q,
12562 "CREATE TYPE %s (\n"
12563 " INTERNALLENGTH = %s",
12564 qualtypname,
12566
12567 /* regproc result is sufficiently quoted already */
12580
12583
12585 {
12589 else
12591 }
12592
12595
12599 zeroIsError));
12600
12602 {
12605 }
12606
12609
12611 {
12614 }
12615
12624
12633
12636
12638
12642 tyinfo->dobj.namespace->dobj.name);
12643
12647 .namespace = tyinfo->dobj.namespace->dobj.name,
12648 .owner = tyinfo->rolname,
12649 .description = "TYPE",
12650 .section = SECTION_PRE_DATA,
12651 .createStmt = q->data,
12652 .dropStmt = delq->data));
12653
12654 /* Dump Type Comments and Security Labels */
12659
12664
12668 tyinfo->dobj.namespace->dobj.name,
12670
12671 PQclear(res);
12672 destroyPQExpBuffer(q);
12674 destroyPQExpBuffer(query);
12677}
12678
12679/*
12680 * dumpDomain
12681 * writes out to fout the queries to recreate a user-defined domain
12682 */
12683static void
12685{
12690 PGresult *res;
12697 Oid typcollation;
12699
12701 {
12702 /* Set up query for domain-specific details */
12703 appendPQExpBufferStr(query,
12704 "PREPARE dumpDomain(pg_catalog.oid) AS\n");
12705
12707 "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
12708 "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
12709 "t.typdefault, "
12710 "CASE WHEN t.typcollation <> u.typcollation "
12711 "THEN t.typcollation ELSE 0 END AS typcollation "
12712 "FROM pg_catalog.pg_type t "
12713 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
12714 "WHERE t.oid = $1");
12715
12717
12719 }
12720
12721 printfPQExpBuffer(query,
12722 "EXECUTE dumpDomain('%u')",
12723 tyinfo->dobj.catId.oid);
12724
12726
12732 {
12735 }
12736 else
12739
12742 tyinfo->dobj.catId.oid,
12743 true, /* force array type */
12744 false); /* force multirange type */
12745
12748
12749 appendPQExpBuffer(q,
12750 "CREATE DOMAIN %s AS %s",
12751 qualtypname,
12752 typdefn);
12753
12754 /* Print collation only if different from base type's collation */
12756 {
12757 CollInfo *coll;
12758
12759 coll = findCollationByOid(typcollation);
12760 if (coll)
12762 }
12763
12764 /*
12765 * Print a not-null constraint if there's one. In servers older than 17
12766 * these don't have names, so just print it unadorned; in newer ones they
12767 * do, but most of the time it's going to be the standard generated one,
12768 * so omit the name in that case also.
12769 */
12771 {
12774 else
12775 {
12777
12779 {
12781
12782 /* XXX should match ChooseConstraintName better */
12784
12787 else
12791 }
12792 }
12793 }
12794
12796 {
12800 else
12802 }
12803
12804 PQclear(res);
12805
12806 /*
12807 * Add any CHECK constraints for the domain
12808 */
12810 {
12812
12816 }
12817
12819
12821
12825 tyinfo->dobj.namespace->dobj.name);
12826
12830 .namespace = tyinfo->dobj.namespace->dobj.name,
12831 .owner = tyinfo->rolname,
12832 .description = "DOMAIN",
12833 .section = SECTION_PRE_DATA,
12834 .createStmt = q->data,
12835 .dropStmt = delq->data));
12836
12837 /* Dump Domain Comments and Security Labels */
12842
12847
12851 tyinfo->dobj.namespace->dobj.name,
12853
12854 /* Dump any per-constraint comments */
12856 {
12859
12860 /* but only if the constraint itself was dumped here */
12862 continue;
12863
12867
12870 tyinfo->dobj.namespace->dobj.name,
12871 tyinfo->rolname,
12873
12875 }
12876
12877 /*
12878 * And a comment on the not-null constraint, if there's one -- but only if
12879 * the constraint itself was dumped here
12880 */
12882 {
12884
12887
12890 tyinfo->dobj.namespace->dobj.name,
12891 tyinfo->rolname,
12894 }
12895
12896 destroyPQExpBuffer(q);
12898 destroyPQExpBuffer(query);
12901}
12902
12903/*
12904 * dumpCompositeType
12905 * writes out to fout the queries to recreate a user-defined stand-alone
12906 * composite type
12907 */
12908static void
12910{
12916 PGresult *res;
12919 int ntups;
12928
12930 {
12931 /*
12932 * Set up query for type-specific details.
12933 *
12934 * Since we only want to dump COLLATE clauses for attributes whose
12935 * collation is different from their type's default, we use a CASE
12936 * here to suppress uninteresting attcollations cheaply. atttypid
12937 * will be 0 for dropped columns; collation does not matter for those.
12938 */
12939 appendPQExpBufferStr(query,
12940 "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
12941 "SELECT a.attname, a.attnum, "
12942 "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
12943 "a.attlen, a.attalign, a.attisdropped, "
12944 "CASE WHEN a.attcollation <> at.typcollation "
12945 "THEN a.attcollation ELSE 0 END AS attcollation "
12946 "FROM pg_catalog.pg_type ct "
12947 "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
12948 "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
12949 "WHERE ct.oid = $1 "
12950 "ORDER BY a.attnum");
12951
12953
12955 }
12956
12957 printfPQExpBuffer(query,
12958 "EXECUTE dumpCompositeType('%u')",
12959 tyinfo->dobj.catId.oid);
12960
12962
12963 ntups = PQntuples(res);
12964
12971
12973 {
12975 tyinfo->dobj.catId.oid,
12976 false, false);
12978 }
12979
12982
12984 qualtypname);
12985
12986 actual_atts = 0;
12988 {
12993 bool attisdropped;
12994 Oid attcollation;
12995
13002
13004 continue;
13005
13006 /* Format properly if not first attr */
13010
13011 if (!attisdropped)
13012 {
13014
13015 /* Add collation if not default for the column type */
13017 {
13018 CollInfo *coll;
13019
13020 coll = findCollationByOid(attcollation);
13021 if (coll)
13023 fmtQualifiedDumpable(coll));
13024 }
13025 }
13026 else
13027 {
13028 /*
13029 * This is a dropped attribute and we're in binary_upgrade mode.
13030 * Insert a placeholder for it in the CREATE TYPE command, and set
13031 * length and alignment with direct UPDATE to the catalogs
13032 * afterwards. See similar code in dumpTableSchema().
13033 */
13035
13036 /* stash separately for insertion after the CREATE TYPE */
13037 appendPQExpBufferStr(dropped,
13038 "\n-- For binary upgrade, recreate dropped column.\n");
13040 "SET attlen = %s, "
13041 "attalign = '%s', attbyval = false\n"
13047
13049 qualtypname);
13052 }
13053 }
13056
13058
13062 tyinfo->dobj.namespace->dobj.name);
13063
13067 .namespace = tyinfo->dobj.namespace->dobj.name,
13068 .owner = tyinfo->rolname,
13069 .description = "TYPE",
13070 .section = SECTION_PRE_DATA,
13071 .createStmt = q->data,
13072 .dropStmt = delq->data));
13073
13074
13075 /* Dump Type Comments and Security Labels */
13080
13085
13089 tyinfo->dobj.namespace->dobj.name,
13091
13092 /* Dump any per-column comments */
13095
13096 PQclear(res);
13097 destroyPQExpBuffer(q);
13098 destroyPQExpBuffer(dropped);
13100 destroyPQExpBuffer(query);
13103}
13104
13105/*
13106 * dumpCompositeTypeColComments
13107 * writes out to fout the queries to recreate comments on the columns of
13108 * a user-defined stand-alone composite type.
13109 *
13110 * The caller has already made a query to collect the names and attnums
13111 * of the type's columns, so we just pass that result into here rather
13112 * than reading them again.
13113 */
13114static void
13116 PGresult *res)
13117{
13120 PQExpBuffer query;
13121 PQExpBuffer target;
13123 int ntups;
13127
13128 /* do nothing, if --no-comments is supplied */
13130 return;
13131
13132 /* Search for comments associated with type's pg_class OID */
13134 &comments);
13135
13136 /* If no comments exist, we're done */
13138 return;
13139
13140 /* Build COMMENT ON statements */
13141 query = createPQExpBuffer();
13142 target = createPQExpBuffer();
13143
13144 ntups = PQntuples(res);
13149 {
13151
13154 {
13157 {
13159 break;
13160 }
13161 }
13163 {
13165
13166 resetPQExpBuffer(target);
13170
13171 resetPQExpBuffer(query);
13177
13180 .namespace = tyinfo->dobj.namespace->dobj.name,
13181 .owner = tyinfo->rolname,
13182 .description = "COMMENT",
13183 .section = SECTION_NONE,
13184 .createStmt = query->data,
13185 .deps = &(tyinfo->dobj.dumpId),
13186 .nDeps = 1));
13187 }
13188
13189 comments++;
13190 ncomments--;
13191 }
13192
13193 destroyPQExpBuffer(query);
13194 destroyPQExpBuffer(target);
13195}
13196
13197/*
13198 * dumpShellType
13199 * writes out to fout the queries to create a shell type
13200 *
13201 * We dump a shell definition in advance of the I/O functions for the type.
13202 */
13203static void
13205{
13207 PQExpBuffer q;
13208
13209 /* Do nothing if not dumping schema */
13211 return;
13212
13213 q = createPQExpBuffer();
13214
13215 /*
13216 * Note the lack of a DROP command for the shell type; any required DROP
13217 * is driven off the base type entry, instead. This interacts with
13218 * _printTocEntry()'s use of the presence of a DROP command to decide
13219 * whether an entry needs an ALTER OWNER command. We don't want to alter
13220 * the shell type's owner immediately on creation; that should happen only
13221 * after it's filled in, otherwise the backend complains.
13222 */
13223
13226 stinfo->baseType->dobj.catId.oid,
13227 false, false);
13228
13231
13235 .namespace = stinfo->dobj.namespace->dobj.name,
13236 .owner = stinfo->baseType->rolname,
13237 .description = "SHELL TYPE",
13238 .section = SECTION_PRE_DATA,
13239 .createStmt = q->data));
13240
13241 destroyPQExpBuffer(q);
13242}
13243
13244/*
13245 * dumpProcLang
13246 * writes out to fout the queries to recreate a user-defined
13247 * procedural language
13248 */
13249static void
13251{
13260
13261 /* Do nothing if not dumping schema */
13263 return;
13264
13265 /*
13266 * Try to find the support function(s). It is not an error if we don't
13267 * find them --- if the functions are in the pg_catalog schema, as is
13268 * standard in 8.1 and up, then we won't have loaded them. (In this case
13269 * we will emit a parameterless CREATE LANGUAGE command, which will
13270 * require PL template knowledge in the backend to reload.)
13271 */
13272
13276
13278 {
13282 }
13283
13285 {
13289 }
13290
13291 /*
13292 * If the functions are dumpable then emit a complete CREATE LANGUAGE with
13293 * parameters. Otherwise, we'll write a parameterless command, which will
13294 * be interpreted as CREATE EXTENSION.
13295 */
13299
13302
13304
13306 qlanname);
13307
13309 {
13312 qlanname);
13321 }
13322 else
13323 {
13324 /*
13325 * If not dumping parameters, then use CREATE OR REPLACE so that the
13326 * command will not fail if the language is preinstalled in the target
13327 * database.
13328 *
13329 * Modern servers will interpret this as CREATE EXTENSION IF NOT
13330 * EXISTS; perhaps we should emit that instead? But it might just add
13331 * confusion.
13332 */
13334 qlanname);
13335 }
13337
13341
13345 .owner = plang->lanowner,
13346 .description = "PROCEDURAL LANGUAGE",
13347 .section = SECTION_PRE_DATA,
13348 .createStmt = defqry->data,
13349 .dropStmt = delqry->data,
13350 ));
13351
13352 /* Dump Proc Lang Comments and Security Labels */
13357
13362
13367
13369
13372}
13373
13374/*
13375 * format_function_arguments: generate function name and argument list
13376 *
13377 * This is used when we can rely on pg_get_function_arguments to format
13378 * the argument list. Note, however, that pg_get_function_arguments
13379 * does not special-case zero-argument aggregates.
13380 */
13381static char *
13383{
13385
13390 else
13393}
13394
13395/*
13396 * format_function_signature: generate function name and argument list
13397 *
13398 * Only a minimal list of input argument types is generated; this is
13399 * sufficient to reference the function, but not to define it.
13400 *
13401 * If honor_quotes is false then the function name is never quoted.
13402 * This is appropriate for use in TOC tags, but not in SQL commands.
13403 */
13404static char *
13406{
13409
13413 else
13416 {
13419
13422 zeroIsError));
13423 }
13426}
13427
13428
13429/*
13430 * dumpFunc:
13431 * dump out one function
13432 */
13433static void
13435{
13437 PQExpBuffer query;
13438 PQExpBuffer q;
13441 PGresult *res;
13447 char *prosrc;
13454 char *prokind;
13467 const char *keyword;
13468
13469 /* Do nothing if not dumping schema */
13471 return;
13472
13473 query = createPQExpBuffer();
13474 q = createPQExpBuffer();
13477
13479 {
13480 /* Set up query for function-specific details */
13481 appendPQExpBufferStr(query,
13482 "PREPARE dumpFunc(pg_catalog.oid) AS\n");
13483
13484 appendPQExpBufferStr(query,
13485 "SELECT\n"
13486 "proretset,\n"
13487 "prosrc,\n"
13488 "probin,\n"
13489 "provolatile,\n"
13490 "proisstrict,\n"
13491 "prosecdef,\n"
13492 "lanname,\n"
13493 "proconfig,\n"
13494 "procost,\n"
13495 "prorows,\n"
13496 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
13497 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n"
13498 "pg_catalog.pg_get_function_result(p.oid) AS funcresult,\n"
13499 "proleakproof,\n");
13500
13501 appendPQExpBufferStr(query,
13502 "array_to_string(protrftypes, ' ') AS protrftypes,\n");
13503
13504 appendPQExpBufferStr(query,
13505 "proparallel,\n");
13506
13508 appendPQExpBufferStr(query,
13509 "prokind,\n");
13510 else
13511 appendPQExpBufferStr(query,
13512 "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind,\n");
13513
13515 appendPQExpBufferStr(query,
13516 "prosupport,\n");
13517 else
13518 appendPQExpBufferStr(query,
13519 "'-' AS prosupport,\n");
13520
13522 appendPQExpBufferStr(query,
13523 "pg_get_function_sqlbody(p.oid) AS prosqlbody\n");
13524 else
13525 appendPQExpBufferStr(query,
13526 "NULL AS prosqlbody\n");
13527
13528 appendPQExpBufferStr(query,
13529 "FROM pg_catalog.pg_proc p, pg_catalog.pg_language l\n"
13530 "WHERE p.oid = $1 "
13531 "AND l.oid = p.prolang");
13532
13534
13536 }
13537
13538 printfPQExpBuffer(query,
13539 "EXECUTE dumpFunc('%u')",
13541
13543
13546 {
13550 }
13551 else
13552 {
13553 prosrc = NULL;
13556 }
13572
13573 /*
13574 * See backend/commands/functioncmds.c for details of how the 'AS' clause
13575 * is used.
13576 */
13578 {
13580 }
13582 {
13585 if (prosrc[0] != '\0')
13586 {
13588
13589 /*
13590 * where we have bin, use dollar quoting if allowed and src
13591 * contains quote or backslash; else use regular quoting.
13592 */
13596 else
13598 }
13599 }
13600 else
13601 {
13603 /* with no bin, dollar quote src unconditionally if allowed */
13606 else
13608 }
13609
13611 {
13614 }
13615 else
13616 {
13618 nconfigitems = 0;
13619 }
13620
13623
13625
13628 funcsig);
13629
13631 keyword = "PROCEDURE";
13632 else
13633 keyword = "FUNCTION"; /* works for window functions too */
13634
13636 keyword, qual_funcsig);
13637
13639 keyword,
13642 funcsig);
13643
13645 /* no result type to output */ ;
13648 else
13652 zeroIsError));
13653
13655
13657 {
13660
13664 {
13669 }
13670
13672 }
13673
13676
13678 {
13686 }
13687
13690
13693
13696
13697 /*
13698 * COST and ROWS are emitted only if present and not default, so as not to
13699 * break backwards-compatibility of the dump without need. Keep this code
13700 * in sync with the defaults in functioncmds.c.
13701 */
13703 {
13705 {
13706 /* default cost is 1 */
13709 }
13710 else
13711 {
13712 /* default cost is 100 */
13715 }
13716 }
13720
13722 {
13723 /* We rely on regprocout to provide quoting and qualification */
13725 }
13726
13728 {
13736 }
13737
13739 {
13740 /* we feel free to scribble on configitems[] here */
13742 char *pos;
13743
13746 continue;
13747 *pos++ = '\0';
13749
13750 /*
13751 * Variables that are marked GUC_LIST_QUOTE were already fully quoted
13752 * by flatten_set_variable_args() before they were put into the
13753 * proconfig array. However, because the quoting rules used there
13754 * aren't exactly like SQL's, we have to break the list value apart
13755 * and then quote the elements as string literals. (The elements may
13756 * be double-quoted as-is, but we can't just feed them to the SQL
13757 * parser; it would do the wrong thing with elements that are
13758 * zero-length or longer than NAMEDATALEN.) Also, we need a special
13759 * case for empty lists.
13760 *
13761 * Variables that are not so marked should just be emitted as simple
13762 * string literals. If the variable is not known to
13763 * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
13764 * to use GUC_LIST_QUOTE for extension variables.
13765 */
13767 {
13770
13771 /* Parse string into list of identifiers */
13772 /* this shouldn't fail really */
13774 {
13775 /* Special case: represent an empty list as NULL */
13779 {
13783 }
13784 }
13786 }
13787 else
13789 }
13790
13792
13794 "pg_catalog.pg_proc", keyword,
13795 qual_funcsig);
13796
13799 keyword, funcsig,
13801
13806 .owner = finfo->rolname,
13807 .description = keyword,
13808 .section = finfo->postponed_def ?
13810 .createStmt = q->data,
13812
13813 /* Dump Function Comments and Security Labels */
13818
13823
13829
13830 PQclear(res);
13831
13832 destroyPQExpBuffer(query);
13833 destroyPQExpBuffer(q);
13841}
13842
13843
13844/*
13845 * Dump a user-defined cast
13846 */
13847static void
13849{
13858
13859 /* Do nothing if not dumping schema */
13861 return;
13862
13863 /* Cannot dump if we don't have the cast function's info */
13865 {
13869 cast->castfunc);
13870 }
13871
13876
13881
13884
13886 {
13889 break;
13892 break;
13895 {
13897
13898 /*
13899 * Always qualify the function name (format_function_signature
13900 * won't qualify it).
13901 */
13905 }
13906 else
13908 break;
13909 default:
13911 }
13912
13918
13921
13924
13928
13932 .description = "CAST",
13933 .section = SECTION_PRE_DATA,
13934 .createStmt = defqry->data,
13935 .dropStmt = delqry->data));
13936
13937 /* Dump Cast Comments */
13942
13947}
13948
13949/*
13950 * Dump a transform
13951 */
13952static void
13954{
13964
13965 /* Do nothing if not dumping schema */
13967 return;
13968
13969 /* Cannot dump if we don't have the transform functions' info */
13971 {
13975 transform->trffromsql);
13976 }
13978 {
13982 transform->trftosql);
13983 }
13984
13989
13992
13995
13998
14000 pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
14001
14003 {
14005 {
14007
14008 /*
14009 * Always qualify the function name (format_function_signature
14010 * won't qualify it).
14011 */
14015 }
14016 else
14018 }
14019
14021 {
14024
14026 {
14028
14029 /*
14030 * Always qualify the function name (format_function_signature
14031 * won't qualify it).
14032 */
14036 }
14037 else
14039 }
14040
14042
14045
14048
14052
14056 .description = "TRANSFORM",
14057 .section = SECTION_PRE_DATA,
14058 .createStmt = defqry->data,
14059 .dropStmt = delqry->data,
14062
14063 /* Dump Transform Comments */
14068
14074}
14075
14076
14077/*
14078 * dumpOpr
14079 * write out a single operator definition
14080 */
14081static void
14083{
14085 PQExpBuffer query;
14086 PQExpBuffer q;
14089 PQExpBuffer details;
14090 PGresult *res;
14101 char *oprkind;
14102 char *oprcode;
14103 char *oprleft;
14104 char *oprright;
14113
14114 /* Do nothing if not dumping schema */
14116 return;
14117
14118 /*
14119 * some operators are invalid because they were the result of user
14120 * defining operators before commutators exist
14121 */
14123 return;
14124
14125 query = createPQExpBuffer();
14126 q = createPQExpBuffer();
14129 details = createPQExpBuffer();
14130
14132 {
14133 /* Set up query for operator-specific details */
14134 appendPQExpBufferStr(query,
14135 "PREPARE dumpOpr(pg_catalog.oid) AS\n"
14136 "SELECT oprkind, "
14137 "oprcode::pg_catalog.regprocedure, "
14138 "oprleft::pg_catalog.regtype, "
14139 "oprright::pg_catalog.regtype, "
14140 "oprcom, "
14141 "oprnegate, "
14142 "oprrest::pg_catalog.regprocedure, "
14143 "oprjoin::pg_catalog.regprocedure, "
14144 "oprcanmerge, oprcanhash "
14145 "FROM pg_catalog.pg_operator "
14146 "WHERE oid = $1");
14147
14149
14151 }
14152
14153 printfPQExpBuffer(query,
14154 "EXECUTE dumpOpr('%u')",
14155 oprinfo->dobj.catId.oid);
14156
14158
14169
14180
14181 /* In PG14 upwards postfix operator support does not exist anymore. */
14184 oprcode);
14185
14188 {
14191 }
14192
14194 oprinfo->dobj.name);
14195
14196 /*
14197 * right unary means there's a left arg and left unary means there's a
14198 * right arg. (Although the "r" case is dead code for PG14 and later,
14199 * continue to support it in case we're dumping from an old server.)
14200 */
14203 {
14206 }
14207 else
14209
14212 {
14215 }
14216 else
14218
14221 {
14224 }
14225
14228 {
14231 }
14232
14235
14238
14241 {
14244 }
14245
14248 {
14251 }
14252
14255 oprid->data);
14256
14260
14264 oprinfo->dobj.namespace->dobj.name);
14265
14269 .namespace = oprinfo->dobj.namespace->dobj.name,
14270 .owner = oprinfo->rolname,
14271 .description = "OPERATOR",
14272 .section = SECTION_PRE_DATA,
14273 .createStmt = q->data,
14274 .dropStmt = delq->data));
14275
14276 /* Dump Operator Comments */
14281
14282 PQclear(res);
14283
14284 destroyPQExpBuffer(query);
14285 destroyPQExpBuffer(q);
14288 destroyPQExpBuffer(details);
14289}
14290
14291/*
14292 * Convert a function reference obtained from pg_operator
14293 *
14294 * Returns allocated string of what to print, or NULL if function references
14295 * is InvalidOid. Returned string is expected to be free'd by the caller.
14296 *
14297 * The input is a REGPROCEDURE display; we have to strip the argument-types
14298 * part.
14299 */
14300static char *
14302{
14306
14307 /* In all cases "-" means a null reference */
14310
14312 /* find non-double-quoted left paren */
14315 {
14317 {
14319 break;
14320 }
14323 }
14325}
14326
14327/*
14328 * getFormattedOperatorName - retrieve the operator name for the
14329 * given operator OID (presented in string form).
14330 *
14331 * Returns an allocated string, or NULL if the given OID is invalid.
14332 * Caller is responsible for free'ing result string.
14333 *
14334 * What we produce has the format "OPERATOR(schema.oprname)". This is only
14335 * useful in commands where the operator's argument types can be inferred from
14336 * context. We always schema-qualify the name, though. The predecessor to
14337 * this code tried to skip the schema qualification if possible, but that led
14338 * to wrong results in corner cases, such as if an operator and its negator
14339 * are in different schemas.
14340 */
14341static char *
14343{
14345
14346 /* In all cases "0" means a null reference */
14349
14352 {
14354 oproid);
14356 }
14357
14360 oprInfo->dobj.name);
14361}
14362
14363/*
14364 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
14365 *
14366 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
14367 * argument lists of these functions are predetermined. Note that the
14368 * caller should ensure we are in the proper schema, because the results
14369 * are search path dependent!
14370 */
14371static char *
14373{
14375 char query[128];
14376 PGresult *res;
14377
14379 "SELECT '%u'::pg_catalog.regproc", funcOid);
14381
14383
14384 PQclear(res);
14385
14387}
14388
14389/*
14390 * dumpAccessMethod
14391 * write out a single access method definition
14392 */
14393static void
14395{
14397 PQExpBuffer q;
14400
14401 /* Do nothing if not dumping schema */
14403 return;
14404
14405 q = createPQExpBuffer();
14407
14409
14411
14413 {
14416 break;
14419 break;
14420 default:
14423 destroyPQExpBuffer(q);
14426 return;
14427 }
14428
14430
14432 qamname);
14433
14437
14441 .description = "ACCESS METHOD",
14442 .section = SECTION_PRE_DATA,
14443 .createStmt = q->data,
14444 .dropStmt = delq->data));
14445
14446 /* Dump Access Method Comments */
14451
14452 destroyPQExpBuffer(q);
14455}
14456
14457/*
14458 * dumpOpclass
14459 * write out a single operator class definition
14460 */
14461static void
14463{
14465 PQExpBuffer query;
14466 PQExpBuffer q;
14469 PGresult *res;
14470 int ntups;
14486 char *opcintype;
14489 char *opcfamily;
14492 char *amname;
14495 char *sortfamily;
14503
14504 /* Do nothing if not dumping schema */
14506 return;
14507
14508 query = createPQExpBuffer();
14509 q = createPQExpBuffer();
14512
14513 /* Get additional fields from the pg_opclass row */
14515 "opckeytype::pg_catalog.regtype, "
14516 "opcdefault, opcfamily, "
14517 "opfname AS opcfamilyname, "
14518 "nspname AS opcfamilynsp, "
14519 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
14520 "FROM pg_catalog.pg_opclass c "
14521 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
14522 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14523 "WHERE c.oid = '%u'::pg_catalog.oid",
14524 opcinfo->dobj.catId.oid);
14525
14527
14535
14536 /* opcintype may still be needed after we PQclear res */
14540 /* opcfamily will still be needed after we PQclear res */
14544 /* amname will still be needed after we PQclear res */
14546
14550 fmtId(amname));
14551
14552 /* Build the fixed portion of the CREATE command */
14558 opcintype,
14559 fmtId(amname));
14561 {
14565 }
14567
14569
14571 {
14573 opckeytype);
14575 }
14576
14577 PQclear(res);
14578
14579 /*
14580 * Now fetch and print the OPERATOR entries (pg_amop rows).
14581 *
14582 * Print only those opfamily members that are tied to the opclass by
14583 * pg_depend entries.
14584 */
14585 resetPQExpBuffer(query);
14587 "amopopr::pg_catalog.regoperator, "
14588 "opfname AS sortfamily, "
14589 "nspname AS sortfamilynsp "
14590 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14591 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14592 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14593 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14594 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14595 "AND refobjid = '%u'::pg_catalog.oid "
14596 "AND amopfamily = '%s'::pg_catalog.oid "
14597 "ORDER BY amopstrategy",
14598 opcinfo->dobj.catId.oid,
14599 opcfamily);
14600
14602
14603 ntups = PQntuples(res);
14604
14609
14611 {
14616
14619
14622
14624 {
14628 }
14629
14631 }
14632
14633 PQclear(res);
14634
14635 /*
14636 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14637 *
14638 * Print only those opfamily members that are tied to the opclass by
14639 * pg_depend entries.
14640 *
14641 * We print the amproclefttype/amprocrighttype even though in most cases
14642 * the backend could deduce the right values, because of the corner case
14643 * of a btree sort support function for a cross-type comparison.
14644 */
14645 resetPQExpBuffer(query);
14646
14648 "amproc::pg_catalog.regprocedure, "
14649 "amproclefttype::pg_catalog.regtype, "
14650 "amprocrighttype::pg_catalog.regtype "
14651 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14652 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
14653 "AND refobjid = '%u'::pg_catalog.oid "
14654 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14655 "AND objid = ap.oid "
14656 "ORDER BY amprocnum",
14657 opcinfo->dobj.catId.oid);
14658
14660
14661 ntups = PQntuples(res);
14662
14667
14669 {
14674
14677
14679
14682
14684
14686 }
14687
14688 PQclear(res);
14689
14690 /*
14691 * If needComma is still false it means we haven't added anything after
14692 * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE
14693 * clause with the same datatype. This isn't sanctioned by the
14694 * documentation, but actually DefineOpClass will treat it as a no-op.
14695 */
14698
14700
14703 fmtId(amname));
14704
14708 opcinfo->dobj.namespace->dobj.name);
14709
14713 .namespace = opcinfo->dobj.namespace->dobj.name,
14714 .owner = opcinfo->rolname,
14715 .description = "OPERATOR CLASS",
14716 .section = SECTION_PRE_DATA,
14717 .createStmt = q->data,
14718 .dropStmt = delq->data));
14719
14720 /* Dump Operator Class Comments */
14725
14726 pg_free(opcintype);
14727 pg_free(opcfamily);
14728 pg_free(amname);
14729 destroyPQExpBuffer(query);
14730 destroyPQExpBuffer(q);
14733}
14734
14735/*
14736 * dumpOpfamily
14737 * write out a single operator family definition
14738 *
14739 * Note: this also dumps any "loose" operator members that aren't bound to a
14740 * specific opclass within the opfamily.
14741 */
14742static void
14744{
14746 PQExpBuffer query;
14747 PQExpBuffer q;
14750 PGresult *res;
14753 int ntups;
14763 char *amname;
14766 char *sortfamily;
14774
14775 /* Do nothing if not dumping schema */
14777 return;
14778
14779 query = createPQExpBuffer();
14780 q = createPQExpBuffer();
14783
14784 /*
14785 * Fetch only those opfamily members that are tied directly to the
14786 * opfamily by pg_depend entries.
14787 */
14789 "amopopr::pg_catalog.regoperator, "
14790 "opfname AS sortfamily, "
14791 "nspname AS sortfamilynsp "
14792 "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
14793 "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
14794 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
14795 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
14796 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14797 "AND refobjid = '%u'::pg_catalog.oid "
14798 "AND amopfamily = '%u'::pg_catalog.oid "
14799 "ORDER BY amopstrategy",
14800 opfinfo->dobj.catId.oid,
14801 opfinfo->dobj.catId.oid);
14802
14804
14805 resetPQExpBuffer(query);
14806
14808 "amproc::pg_catalog.regprocedure, "
14809 "amproclefttype::pg_catalog.regtype, "
14810 "amprocrighttype::pg_catalog.regtype "
14811 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
14812 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
14813 "AND refobjid = '%u'::pg_catalog.oid "
14814 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
14815 "AND objid = ap.oid "
14816 "ORDER BY amprocnum",
14817 opfinfo->dobj.catId.oid);
14818
14820
14821 /* Get additional fields from the pg_opfamily row */
14822 resetPQExpBuffer(query);
14823
14825 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
14826 "FROM pg_catalog.pg_opfamily "
14827 "WHERE oid = '%u'::pg_catalog.oid",
14828 opfinfo->dobj.catId.oid);
14829
14831
14833
14834 /* amname will still be needed after we PQclear res */
14836
14840 fmtId(amname));
14841
14842 /* Build the fixed portion of the CREATE command */
14846 fmtId(amname));
14847
14848 PQclear(res);
14849
14850 /* Do we need an ALTER to add loose members? */
14852 {
14856 fmtId(amname));
14857
14859
14860 /*
14861 * Now fetch and print the OPERATOR entries (pg_amop rows).
14862 */
14864
14869
14871 {
14876
14879
14882
14884 {
14888 }
14889
14891 }
14892
14893 /*
14894 * Now fetch and print the FUNCTION entries (pg_amproc rows).
14895 */
14897
14902
14904 {
14909
14912
14915 amproc);
14916
14918 }
14919
14921 }
14922
14925 fmtId(amname));
14926
14930 opfinfo->dobj.namespace->dobj.name);
14931
14935 .namespace = opfinfo->dobj.namespace->dobj.name,
14936 .owner = opfinfo->rolname,
14937 .description = "OPERATOR FAMILY",
14938 .section = SECTION_PRE_DATA,
14939 .createStmt = q->data,
14940 .dropStmt = delq->data));
14941
14942 /* Dump Operator Family Comments */
14947
14948 pg_free(amname);
14951 destroyPQExpBuffer(query);
14952 destroyPQExpBuffer(q);
14955}
14956
14957/*
14958 * dumpCollation
14959 * write out a single collation definition
14960 */
14961static void
14963{
14965 PQExpBuffer query;
14966 PQExpBuffer q;
14969 PGresult *res;
14981
14982 /* Do nothing if not dumping schema */
14984 return;
14985
14986 query = createPQExpBuffer();
14987 q = createPQExpBuffer();
14989
14991
14992 /* Get collation-specific details */
14994
14995 appendPQExpBufferStr(query,
14996 "collprovider, "
14997 "collversion, ");
14998
15000 appendPQExpBufferStr(query,
15001 "collisdeterministic, ");
15002 else
15003 appendPQExpBufferStr(query,
15004 "true AS collisdeterministic, ");
15005
15007 appendPQExpBufferStr(query,
15008 "colllocale, ");
15010 appendPQExpBufferStr(query,
15011 "colliculocale AS colllocale, ");
15012 else
15013 appendPQExpBufferStr(query,
15014 "NULL AS colllocale, ");
15015
15017 appendPQExpBufferStr(query,
15018 "collicurules, ");
15019 else
15020 appendPQExpBufferStr(query,
15021 "NULL AS collicurules, ");
15022
15023 appendPQExpBuffer(query,
15024 "collcollate, "
15025 "collctype "
15026 "FROM pg_catalog.pg_collation c "
15027 "WHERE c.oid = '%u'::pg_catalog.oid",
15028 collinfo->dobj.catId.oid);
15029
15031
15038
15040
15043 else
15045
15048 else
15050
15051 /*
15052 * Before version 15, collcollate and collctype were of type NAME and
15053 * non-nullable. Treat empty strings as NULL for consistency.
15054 */
15056 {
15061 }
15062
15065 else
15067
15070 else
15072
15075
15078
15087 /* to allow dumping pg_catalog; not accepted on input */
15089 else
15091 collprovider);
15092
15095
15097 {
15100
15101 /* no locale -- the default collation cannot be reloaded anyway */
15102 }
15104 {
15107
15110 fout);
15111 }
15113 {
15115 {
15118
15121 fout);
15122 }
15123 else
15124 {
15128
15131 }
15132
15134 {
15137 }
15138 }
15140 {
15143
15145 {
15148 }
15149 else
15150 {
15155 }
15156 }
15157 else
15159
15160 /*
15161 * For binary upgrade, carry over the collation version. For normal
15162 * dump/restore, omit the version, so that it is computed upon restore.
15163 */
15165 {
15167
15170 {
15172 appendStringLiteralAH(q,
15174 fout);
15175 }
15176 }
15177
15179
15183 collinfo->dobj.namespace->dobj.name);
15184
15188 .namespace = collinfo->dobj.namespace->dobj.name,
15189 .owner = collinfo->rolname,
15190 .description = "COLLATION",
15191 .section = SECTION_PRE_DATA,
15192 .createStmt = q->data,
15193 .dropStmt = delq->data));
15194
15195 /* Dump Collation Comments */
15200
15201 PQclear(res);
15202
15203 destroyPQExpBuffer(query);
15204 destroyPQExpBuffer(q);
15207}
15208
15209/*
15210 * dumpConversion
15211 * write out a single conversion definition
15212 */
15213static void
15215{
15217 PQExpBuffer query;
15218 PQExpBuffer q;
15221 PGresult *res;
15230
15231 /* Do nothing if not dumping schema */
15233 return;
15234
15235 query = createPQExpBuffer();
15236 q = createPQExpBuffer();
15238
15240
15241 /* Get conversion-specific details */
15243 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
15244 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
15245 "conproc, condefault "
15246 "FROM pg_catalog.pg_conversion c "
15247 "WHERE c.oid = '%u'::pg_catalog.oid",
15248 convinfo->dobj.catId.oid);
15249
15251
15256
15261
15264
15271 /* regproc output is already sufficiently quoted */
15273
15277 convinfo->dobj.namespace->dobj.name);
15278
15282 .namespace = convinfo->dobj.namespace->dobj.name,
15283 .owner = convinfo->rolname,
15284 .description = "CONVERSION",
15285 .section = SECTION_PRE_DATA,
15286 .createStmt = q->data,
15287 .dropStmt = delq->data));
15288
15289 /* Dump Conversion Comments */
15294
15295 PQclear(res);
15296
15297 destroyPQExpBuffer(query);
15298 destroyPQExpBuffer(q);
15301}
15302
15303/*
15304 * format_aggregate_signature: generate aggregate name and argument list
15305 *
15306 * The argument type names are qualified if needed. The aggregate name
15307 * is never qualified.
15308 */
15309static char *
15311{
15314
15318 else
15320
15323 else
15324 {
15331 zeroIsError));
15333 }
15335}
15336
15337/*
15338 * dumpAgg
15339 * write out a single aggregate definition
15340 */
15341static void
15343{
15345 PQExpBuffer query;
15346 PQExpBuffer q;
15348 PQExpBuffer details;
15352 PGresult *res;
15367 const char *aggsortop;
15370 const char *aggtranstype;
15371 const char *aggtransspace;
15378
15379 /* Do nothing if not dumping schema */
15381 return;
15382
15383 query = createPQExpBuffer();
15384 q = createPQExpBuffer();
15386 details = createPQExpBuffer();
15387
15389 {
15390 /* Set up query for aggregate-specific details */
15391 appendPQExpBufferStr(query,
15392 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15393
15394 appendPQExpBufferStr(query,
15395 "SELECT "
15396 "aggtransfn,\n"
15397 "aggfinalfn,\n"
15398 "aggtranstype::pg_catalog.regtype,\n"
15399 "agginitval,\n"
15400 "aggsortop,\n"
15401 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15402 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15403
15404 appendPQExpBufferStr(query,
15405 "aggkind,\n"
15406 "aggmtransfn,\n"
15407 "aggminvtransfn,\n"
15408 "aggmfinalfn,\n"
15409 "aggmtranstype::pg_catalog.regtype,\n"
15410 "aggfinalextra,\n"
15411 "aggmfinalextra,\n"
15412 "aggtransspace,\n"
15413 "aggmtransspace,\n"
15414 "aggminitval,\n");
15415
15416 appendPQExpBufferStr(query,
15417 "aggcombinefn,\n"
15418 "aggserialfn,\n"
15419 "aggdeserialfn,\n"
15420 "proparallel,\n");
15421
15423 appendPQExpBufferStr(query,
15424 "aggfinalmodify,\n"
15425 "aggmfinalmodify\n");
15426 else
15427 appendPQExpBufferStr(query,
15428 "'0' AS aggfinalmodify,\n"
15429 "'0' AS aggmfinalmodify\n");
15430
15431 appendPQExpBufferStr(query,
15432 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15433 "WHERE a.aggfnoid = p.oid "
15434 "AND p.oid = $1");
15435
15437
15439 }
15440
15441 printfPQExpBuffer(query,
15442 "EXECUTE dumpAgg('%u')",
15443 agginfo->aggfn.dobj.catId.oid);
15444
15446
15449
15471
15472 {
15475
15480 }
15481
15483
15484 /* identify default modify flag for aggkind (must match DefineAggregate) */
15485 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
15486 /* replace omitted flags for old versions */
15491
15492 /* regproc and regtype output is already sufficiently quoted */
15494 aggtransfn, aggtranstype);
15495
15497 {
15499 aggtransspace);
15500 }
15501
15503 {
15506 }
15507
15509 {
15511 aggfinalfn);
15515 {
15517 {
15520 break;
15523 break;
15526 break;
15527 default:
15529 agginfo->aggfn.dobj.name);
15530 break;
15531 }
15532 }
15533 }
15534
15537
15540
15543
15545 {
15547 aggmtransfn,
15548 aggminvtransfn,
15549 aggmtranstype);
15550 }
15551
15553 {
15555 aggmtransspace);
15556 }
15557
15559 {
15562 }
15563
15565 {
15567 aggmfinalfn);
15571 {
15573 {
15576 break;
15579 break;
15582 break;
15583 default:
15585 agginfo->aggfn.dobj.name);
15586 break;
15587 }
15588 }
15589 }
15590
15593 {
15595 aggsortconvop);
15597 }
15598
15601
15603 {
15610 agginfo->aggfn.dobj.name);
15611 }
15612
15615 aggsig);
15616
15620
15624 agginfo->aggfn.dobj.namespace->dobj.name);
15625
15628 agginfo->aggfn.dobj.dumpId,
15631 .owner = agginfo->aggfn.rolname,
15632 .description = "AGGREGATE",
15633 .section = SECTION_PRE_DATA,
15634 .createStmt = q->data,
15635 .dropStmt = delq->data));
15636
15637 /* Dump Aggregate Comments */
15640 agginfo->aggfn.dobj.namespace->dobj.name,
15641 agginfo->aggfn.rolname,
15643
15646 agginfo->aggfn.dobj.namespace->dobj.name,
15647 agginfo->aggfn.rolname,
15649
15650 /*
15651 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
15652 * command look like a function's GRANT; in particular this affects the
15653 * syntax for zero-argument aggregates and ordered-set aggregates.
15654 */
15656
15658
15662 agginfo->aggfn.dobj.namespace->dobj.name,
15664
15668
15669 PQclear(res);
15670
15671 destroyPQExpBuffer(query);
15672 destroyPQExpBuffer(q);
15674 destroyPQExpBuffer(details);
15675}
15676
15677/*
15678 * dumpTSParser
15679 * write out a single text search parser
15680 */
15681static void
15683{
15685 PQExpBuffer q;
15688
15689 /* Do nothing if not dumping schema */
15691 return;
15692
15693 q = createPQExpBuffer();
15695
15697
15700
15712
15715
15719 prsinfo->dobj.namespace->dobj.name);
15720
15724 .namespace = prsinfo->dobj.namespace->dobj.name,
15725 .description = "TEXT SEARCH PARSER",
15726 .section = SECTION_PRE_DATA,
15727 .createStmt = q->data,
15728 .dropStmt = delq->data));
15729
15730 /* Dump Parser Comments */
15735
15736 destroyPQExpBuffer(q);
15739}
15740
15741/*
15742 * dumpTSDictionary
15743 * write out a single text search dictionary
15744 */
15745static void
15747{
15749 PQExpBuffer q;
15751 PQExpBuffer query;
15753 PGresult *res;
15754 char *nspname;
15756
15757 /* Do nothing if not dumping schema */
15759 return;
15760
15761 q = createPQExpBuffer();
15763 query = createPQExpBuffer();
15764
15766
15767 /* Fetch name and namespace of the dictionary's template */
15769 "FROM pg_ts_template p, pg_namespace n "
15770 "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
15771 dictinfo->dicttemplate);
15773 nspname = PQgetvalue(res, 0, 0);
15775
15778
15782
15783 PQclear(res);
15784
15785 /* the dictinitoption can be dumped straight into the command */
15788
15790
15793
15797 dictinfo->dobj.namespace->dobj.name);
15798
15802 .namespace = dictinfo->dobj.namespace->dobj.name,
15803 .owner = dictinfo->rolname,
15804 .description = "TEXT SEARCH DICTIONARY",
15805 .section = SECTION_PRE_DATA,
15806 .createStmt = q->data,
15807 .dropStmt = delq->data));
15808
15809 /* Dump Dictionary Comments */
15814
15815 destroyPQExpBuffer(q);
15817 destroyPQExpBuffer(query);
15819}
15820
15821/*
15822 * dumpTSTemplate
15823 * write out a single text search template
15824 */
15825static void
15827{
15829 PQExpBuffer q;
15832
15833 /* Do nothing if not dumping schema */
15835 return;
15836
15837 q = createPQExpBuffer();
15839
15841
15844
15850
15853
15857 tmplinfo->dobj.namespace->dobj.name);
15858
15862 .namespace = tmplinfo->dobj.namespace->dobj.name,
15863 .description = "TEXT SEARCH TEMPLATE",
15864 .section = SECTION_PRE_DATA,
15865 .createStmt = q->data,
15866 .dropStmt = delq->data));
15867
15868 /* Dump Template Comments */
15873
15874 destroyPQExpBuffer(q);
15877}
15878
15879/*
15880 * dumpTSConfig
15881 * write out a single text search configuration
15882 */
15883static void
15885{
15887 PQExpBuffer q;
15889 PQExpBuffer query;
15891 PGresult *res;
15892 char *nspname;
15894 int ntups,
15895 i;
15898
15899 /* Do nothing if not dumping schema */
15901 return;
15902
15903 q = createPQExpBuffer();
15905 query = createPQExpBuffer();
15906
15908
15909 /* Fetch name and namespace of the config's parser */
15911 "FROM pg_ts_parser p, pg_namespace n "
15912 "WHERE p.oid = '%u' AND n.oid = prsnamespace",
15913 cfginfo->cfgparser);
15915 nspname = PQgetvalue(res, 0, 0);
15917
15920
15923
15924 PQclear(res);
15925
15926 resetPQExpBuffer(query);
15927 appendPQExpBuffer(query,
15928 "SELECT\n"
15929 " ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t\n"
15930 " WHERE t.tokid = m.maptokentype ) AS tokenname,\n"
15931 " m.mapdict::pg_catalog.regdictionary AS dictname\n"
15932 "FROM pg_catalog.pg_ts_config_map AS m\n"
15933 "WHERE m.mapcfg = '%u'\n"
15934 "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
15936
15938 ntups = PQntuples(res);
15939
15942
15944 {
15947
15950 {
15951 /* starting a new token type, so start a new command */
15956 /* tokenname needs quoting, dictname does NOT */
15959 }
15960 else
15962 }
15963
15964 if (ntups > 0)
15966
15967 PQclear(res);
15968
15971
15975 cfginfo->dobj.namespace->dobj.name);
15976
15980 .namespace = cfginfo->dobj.namespace->dobj.name,
15981 .owner = cfginfo->rolname,
15982 .description = "TEXT SEARCH CONFIGURATION",
15983 .section = SECTION_PRE_DATA,
15984 .createStmt = q->data,
15985 .dropStmt = delq->data));
15986
15987 /* Dump Configuration Comments */
15992
15993 destroyPQExpBuffer(q);
15995 destroyPQExpBuffer(query);
15997}
15998
15999/*
16000 * dumpForeignDataWrapper
16001 * write out a single foreign-data wrapper definition
16002 */
16003static void
16005{
16007 PQExpBuffer q;
16010
16011 /* Do nothing if not dumping schema */
16013 return;
16014
16015 q = createPQExpBuffer();
16017
16019
16021 qfdwname);
16022
16025
16028
16031
16034
16036
16038 qfdwname);
16039
16043 NULL);
16044
16048 .owner = fdwinfo->rolname,
16049 .description = "FOREIGN DATA WRAPPER",
16050 .section = SECTION_PRE_DATA,
16051 .createStmt = q->data,
16052 .dropStmt = delq->data));
16053
16054 /* Dump Foreign Data Wrapper Comments */
16059
16060 /* Handle the ACL */
16065
16067
16068 destroyPQExpBuffer(q);
16070}
16071
16072/*
16073 * dumpForeignServer
16074 * write out a foreign server definition
16075 */
16076static void
16078{
16080 PQExpBuffer q;
16082 PQExpBuffer query;
16083 PGresult *res;
16085 char *fdwname;
16086
16087 /* Do nothing if not dumping schema */
16089 return;
16090
16091 q = createPQExpBuffer();
16093 query = createPQExpBuffer();
16094
16096
16097 /* look up the foreign-data wrapper */
16099 "FROM pg_foreign_data_wrapper w "
16100 "WHERE w.oid = '%u'",
16101 srvinfo->srvfdw);
16103 fdwname = PQgetvalue(res, 0, 0);
16104
16107 {
16110 }
16112 {
16115 }
16116
16119
16122
16124
16126 qsrvname);
16127
16131
16135 .owner = srvinfo->rolname,
16136 .description = "SERVER",
16137 .section = SECTION_PRE_DATA,
16138 .createStmt = q->data,
16139 .dropStmt = delq->data));
16140
16141 /* Dump Foreign Server Comments */
16146
16147 /* Handle the ACL */
16152
16153 /* Dump user mappings */
16157 srvinfo->rolname,
16159
16160 PQclear(res);
16161
16163
16164 destroyPQExpBuffer(q);
16166 destroyPQExpBuffer(query);
16167}
16168
16169/*
16170 * dumpUserMappings
16171 *
16172 * This routine is used to dump any user mappings associated with the
16173 * server handed to this routine. Should be called after ArchiveEntry()
16174 * for the server.
16175 */
16176static void
16178 const char *servername, const char *namespace,
16179 const char *owner,
16181{
16182 PQExpBuffer q;
16184 PQExpBuffer query;
16185 PQExpBuffer tag;
16186 PGresult *res;
16187 int ntups;
16191
16192 q = createPQExpBuffer();
16193 tag = createPQExpBuffer();
16195 query = createPQExpBuffer();
16196
16197 /*
16198 * We read from the publicly accessible view pg_user_mappings, so as not
16199 * to fail if run by a non-superuser. Note that the view will show
16200 * umoptions as null if the user hasn't got privileges for the associated
16201 * server; this means that pg_dump will dump such a mapping, but with no
16202 * OPTIONS clause. A possible alternative is to skip such mappings
16203 * altogether, but it's not clear that that's an improvement.
16204 */
16205 appendPQExpBuffer(query,
16206 "SELECT usename, "
16207 "array_to_string(ARRAY("
16208 "SELECT quote_ident(option_name) || ' ' || "
16209 "quote_literal(option_value) "
16210 "FROM pg_options_to_table(umoptions) "
16211 "ORDER BY option_name"
16212 "), E',\n ') AS umoptions "
16213 "FROM pg_user_mappings "
16214 "WHERE srvid = '%u' "
16215 "ORDER BY usename",
16216 catalogId.oid);
16217
16219
16220 ntups = PQntuples(res);
16223
16225 {
16228
16231
16232 resetPQExpBuffer(q);
16235
16238
16240
16244
16245 resetPQExpBuffer(tag);
16247 usename, servername);
16248
16251 .namespace = namespace,
16252 .owner = owner,
16253 .description = "USER MAPPING",
16254 .section = SECTION_PRE_DATA,
16255 .createStmt = q->data,
16256 .dropStmt = delq->data));
16257 }
16258
16259 PQclear(res);
16260
16261 destroyPQExpBuffer(query);
16263 destroyPQExpBuffer(tag);
16264 destroyPQExpBuffer(q);
16265}
16266
16267/*
16268 * Write out default privileges information
16269 */
16270static void
16272{
16274 PQExpBuffer q;
16275 PQExpBuffer tag;
16277
16278 /* Do nothing if not dumping schema, or if we're skipping ACLs */
16280 return;
16281
16282 q = createPQExpBuffer();
16283 tag = createPQExpBuffer();
16284
16286 {
16289 break;
16292 break;
16295 break;
16298 break;
16301 break;
16304 break;
16305 default:
16306 /* shouldn't get here */
16310 }
16311
16313
16314 /* build the actual command(s) for this tuple */
16318 daclinfo->dacl.acl,
16320 daclinfo->defaclrole,
16321 fout->remoteVersion,
16322 q))
16324 daclinfo->dacl.acl);
16325
16329 .namespace = daclinfo->dobj.namespace ?
16331 .owner = daclinfo->defaclrole,
16333 .section = SECTION_POST_DATA,
16334 .createStmt = q->data));
16335
16336 destroyPQExpBuffer(tag);
16337 destroyPQExpBuffer(q);
16338}
16339
16340/*----------
16341 * Write out grant/revoke information
16342 *
16343 * 'objDumpId' is the dump ID of the underlying object.
16344 * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
16345 * or InvalidDumpId if there is no need for a second dependency.
16346 * 'type' must be one of
16347 * TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
16348 * FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
16349 * 'name' is the formatted name of the object. Must be quoted etc. already.
16350 * 'subname' is the formatted name of the sub-object, if any. Must be quoted.
16351 * (Currently we assume that subname is only provided for table columns.)
16352 * 'nspname' is the namespace the object is in (NULL if none).
16353 * 'tag' is the tag to use for the ACL TOC entry; typically, this is NULL
16354 * to use the default for the object type.
16355 * 'owner' is the owner, NULL if there is no owner (for languages).
16356 * 'dacl' is the DumpableAcl struct for the object.
16357 *
16358 * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
16359 * no ACL entry was created.
16360 *----------
16361 */
16365 const char *nspname, const char *tag, const char *owner,
16367{
16375 PQExpBuffer sql;
16376
16377 /* Do nothing if ACL dump is not enabled */
16380
16381 /* --data-only skips ACLs *except* large object ACLs */
16384
16385 sql = createPQExpBuffer();
16386
16387 /*
16388 * In binary upgrade mode, we don't run an extension's script but instead
16389 * dump out the objects independently and then recreate them. To preserve
16390 * any initial privileges which were set on extension objects, we need to
16391 * compute the set of GRANT and REVOKE commands necessary to get from the
16392 * default privileges of an object to its initial privileges as recorded
16393 * in pg_init_privs.
16394 *
16395 * At restore time, we apply these commands after having called
16396 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16397 * copy the results into pg_init_privs. This is how we preserve the
16398 * contents of that catalog across binary upgrades.
16399 */
16401 initprivs && *initprivs != '\0')
16402 {
16405 initprivs, acldefault, owner,
16409 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16410 }
16411
16412 /*
16413 * Now figure the GRANT and REVOKE commands needed to get to the object's
16414 * actual current ACL, starting from the initprivs if given, else from the
16415 * object-type-specific default. Also, while buildACLCommands will assume
16416 * that a NULL/empty acls string means it needn't do anything, what that
16417 * actually represents is the object-type-specific default; so we need to
16418 * substitute the acldefault string to get the right results in that case.
16419 */
16420 if (initprivs && *initprivs != '\0')
16421 {
16422 baseacls = initprivs;
16425 }
16426 else
16428
16434
16436 {
16439 int nDeps = 0;
16440
16441 if (tag)
16445 else
16447
16451
16453
16456 .namespace = nspname,
16457 .owner = owner,
16458 .description = "ACL",
16459 .section = SECTION_NONE,
16460 .createStmt = sql->data,
16461 .deps = aclDeps,
16462 .nDeps = nDeps));
16463
16465 }
16466
16467 destroyPQExpBuffer(sql);
16468
16470}
16471
16472/*
16473 * dumpSecLabel
16474 *
16475 * This routine is used to dump any security labels associated with the
16476 * object handed to this routine. The routine takes the object type
16477 * and object name (ready to print, except for schema decoration), plus
16478 * the namespace and owner of the object (for labeling the ArchiveEntry),
16479 * plus catalog ID and subid which are the lookup key for pg_seclabel,
16480 * plus the dump ID for the object (for setting a dependency).
16481 * If a matching pg_seclabel entry is found, it is dumped.
16482 *
16483 * Note: although this routine takes a dumpId for dependency purposes,
16484 * that purpose is just to mark the dependency in the emitted dump file
16485 * for possible future use by pg_restore. We do NOT use it for determining
16486 * ordering of the label in the dump file, because this routine is called
16487 * after dependency sorting occurs. This routine should be called just after
16488 * calling ArchiveEntry() for the specified object.
16489 */
16490static void
16492 const char *namespace, const char *owner,
16494{
16496 SecLabelItem *labels;
16499 PQExpBuffer query;
16500
16501 /* do nothing, if --no-security-labels is supplied */
16503 return;
16504
16505 /*
16506 * Security labels are schema not data ... except large object labels are
16507 * data
16508 */
16510 {
16512 return;
16513 }
16514 else
16515 {
16516 /* We do dump large object security labels in binary-upgrade mode */
16518 return;
16519 }
16520
16521 /* Search for security labels associated with catalogId, using table */
16523
16524 query = createPQExpBuffer();
16525
16527 {
16528 /*
16529 * Ignore label entries for which the subid doesn't match.
16530 */
16532 continue;
16533
16534 appendPQExpBuffer(query,
16535 "SECURITY LABEL FOR %s ON %s ",
16537 if (namespace && *namespace)
16542 }
16543
16545 {
16547
16551 .namespace = namespace,
16552 .owner = owner,
16553 .description = "SECURITY LABEL",
16554 .section = SECTION_NONE,
16555 .createStmt = query->data,
16556 .deps = &dumpId,
16557 .nDeps = 1));
16558 destroyPQExpBuffer(tag);
16559 }
16560
16561 destroyPQExpBuffer(query);
16562}
16563
16564/*
16565 * dumpTableSecLabel
16566 *
16567 * As above, but dump security label for both the specified table (or view)
16568 * and its columns.
16569 */
16570static void
16572{
16574 SecLabelItem *labels;
16577 PQExpBuffer query;
16578 PQExpBuffer target;
16579
16580 /* do nothing, if --no-security-labels is supplied */
16582 return;
16583
16584 /* SecLabel are SCHEMA not data */
16586 return;
16587
16588 /* Search for comments associated with relation, using table */
16590 tbinfo->dobj.catId.oid,
16591 &labels);
16592
16593 /* If security labels exist, build SECURITY LABEL statements */
16595 return;
16596
16597 query = createPQExpBuffer();
16598 target = createPQExpBuffer();
16599
16601 {
16602 const char *colname;
16606
16607 resetPQExpBuffer(target);
16608 if (objsubid == 0)
16609 {
16612 }
16613 else
16614 {
16616 /* first fmtXXX result must be consumed before calling again */
16620 }
16625 }
16627 {
16628 resetPQExpBuffer(target);
16633 .namespace = tbinfo->dobj.namespace->dobj.name,
16634 .owner = tbinfo->rolname,
16635 .description = "SECURITY LABEL",
16636 .section = SECTION_NONE,
16637 .createStmt = query->data,
16638 .deps = &(tbinfo->dobj.dumpId),
16639 .nDeps = 1));
16640 }
16641 destroyPQExpBuffer(query);
16642 destroyPQExpBuffer(target);
16643}
16644
16645/*
16646 * findSecLabels
16647 *
16648 * Find the security label(s), if any, associated with the given object.
16649 * All the objsubid values associated with the given classoid/objoid are
16650 * found with one search.
16651 */
16652static int
16654{
16656 SecLabelItem *low;
16657 SecLabelItem *high;
16658 int nmatch;
16659
16661 {
16663 return 0;
16664 }
16665
16666 /*
16667 * Do binary search to find some item matching the object.
16668 */
16669 low = &seclabels[0];
16671 while (low <= high)
16672 {
16673 middle = low + (high - low) / 2;
16674
16676 high = middle - 1;
16678 low = middle + 1;
16680 high = middle - 1;
16682 low = middle + 1;
16683 else
16684 break; /* found a match */
16685 }
16686
16687 if (low > high) /* no matches */
16688 {
16690 return 0;
16691 }
16692
16693 /*
16694 * Now determine how many items match the object. The search loop
16695 * invariant still holds: only items between low and high inclusive could
16696 * match.
16697 */
16698 nmatch = 1;
16700 {
16702 objoid != middle[-1].objoid)
16703 break;
16704 middle--;
16705 nmatch++;
16706 }
16707
16709
16710 middle += nmatch;
16712 {
16714 objoid != middle->objoid)
16715 break;
16716 middle++;
16717 nmatch++;
16718 }
16719
16720 return nmatch;
16721}
16722
16723/*
16724 * collectSecLabels
16725 *
16726 * Construct a table of all security labels available for database objects;
16727 * also set the has-seclabel component flag for each relevant object.
16728 *
16729 * The table is sorted by classoid/objid/objsubid for speed in lookup.
16730 */
16731static void
16733{
16734 PGresult *res;
16735 PQExpBuffer query;
16741 int ntups;
16743 DumpableObject *dobj;
16744
16745 query = createPQExpBuffer();
16746
16747 appendPQExpBufferStr(query,
16748 "SELECT label, provider, classoid, objoid, objsubid "
16749 "FROM pg_catalog.pg_seclabels "
16750 "ORDER BY classoid, objoid, objsubid");
16751
16753
16754 /* Construct lookup table containing OIDs in numeric form */
16760
16761 ntups = PQntuples(res);
16762
16764 nseclabels = 0;
16765 dobj = NULL;
16766
16768 {
16769 CatalogId objId;
16770 int subid;
16771
16775
16776 /* We needn't remember labels that don't match any dumpable object */
16780 dobj = findObjectByCatalogId(objId);
16782 continue;
16783
16784 /*
16785 * Labels on columns of composite types are linked to the type's
16786 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16787 * in the type's own DumpableObject.
16788 */
16791 {
16793
16797 }
16798 else
16799 dobj->components |= DUMP_COMPONENT_SECLABEL;
16800
16806 nseclabels++;
16807 }
16808
16809 PQclear(res);
16810 destroyPQExpBuffer(query);
16811}
16812
16813/*
16814 * dumpTable
16815 * write out to fout the declarations (not data) of a user-defined table
16816 */
16817static void
16819{
16823
16824 /* Do nothing if not dumping schema */
16826 return;
16827
16829 {
16832 else
16834 }
16835
16836 /* Handle the ACL here */
16839 {
16840 const char *objtype;
16841
16843 {
16845 objtype = "SEQUENCE";
16846 break;
16848 objtype = "PROPERTY GRAPH";
16849 break;
16850 default:
16851 objtype = "TABLE";
16852 break;
16853 }
16854
16855 tableAclDumpId =
16858 tbinfo->dobj.namespace->dobj.name,
16860 }
16861
16862 /*
16863 * Handle column ACLs, if any. Note: we pull these with a separate query
16864 * rather than trying to fetch them during getTableAttrs, so that we won't
16865 * miss ACLs on system columns. Doing it this way also allows us to dump
16866 * ACLs for catalogs that we didn't mark "interesting" back in getTables.
16867 */
16869 {
16871 PGresult *res;
16873
16875 {
16876 /* Set up query for column ACLs */
16877 appendPQExpBufferStr(query,
16878 "PREPARE getColumnACLs(pg_catalog.oid) AS\n");
16879
16880 /*
16881 * In principle we should call acldefault('c', relowner) to get
16882 * the default ACL for a column. However, we don't currently
16883 * store the numeric OID of the relowner in TableInfo. We could
16884 * convert the owner name using regrole, but that creates a risk
16885 * of failure due to concurrent role renames. Given that the
16886 * default ACL for columns is empty and is likely to stay that
16887 * way, it's not worth extra cycles and risk to avoid hard-wiring
16888 * that knowledge here.
16889 */
16890 appendPQExpBufferStr(query,
16891 "SELECT at.attname, "
16892 "at.attacl, "
16893 "'{}' AS acldefault, "
16894 "pip.privtype, pip.initprivs "
16895 "FROM pg_catalog.pg_attribute at "
16896 "LEFT JOIN pg_catalog.pg_init_privs pip ON "
16897 "(at.attrelid = pip.objoid "
16898 "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
16899 "AND at.attnum = pip.objsubid) "
16900 "WHERE at.attrelid = $1 AND "
16901 "NOT at.attisdropped "
16902 "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
16903 "ORDER BY at.attnum");
16904
16906
16908 }
16909
16910 printfPQExpBuffer(query,
16911 "EXECUTE getColumnACLs('%u')",
16912 tbinfo->dobj.catId.oid);
16913
16915
16917 {
16925
16928 coldacl.privtype = privtype;
16929 coldacl.initprivs = initprivs;
16931
16932 /*
16933 * Column's GRANT type is always TABLE. Each column ACL depends
16934 * on the table-level ACL, since we can restore column ACLs in
16935 * parallel but the table-level ACL has to be done first.
16936 */
16939 tbinfo->dobj.namespace->dobj.name,
16942 }
16943 PQclear(res);
16944 destroyPQExpBuffer(query);
16945 }
16946
16948}
16949
16950/*
16951 * Create the AS clause for a view or materialized view. The semicolon is
16952 * stripped because a materialized view must add a WITH NO DATA clause.
16953 *
16954 * This returns a new buffer which must be freed by the caller.
16955 */
16958{
16961 PGresult *res;
16963
16964 /* Fetch the view definition */
16965 appendPQExpBuffer(query,
16966 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
16967 tbinfo->dobj.catId.oid);
16968
16970
16972 {
16975 tbinfo->dobj.name);
16976 else
16978 tbinfo->dobj.name);
16979 }
16980
16982
16985 tbinfo->dobj.name);
16986
16987 /* Strip off the trailing semicolon so that other things may follow. */
16990
16991 PQclear(res);
16992 destroyPQExpBuffer(query);
16993
16995}
16996
16997/*
16998 * Create a dummy AS clause for a view. This is used when the real view
16999 * definition has to be postponed because of circular dependencies.
17000 * We must duplicate the view's external properties -- column names and types
17001 * (including collation) -- so that it works for subsequent references.
17002 *
17003 * This returns a new buffer which must be freed by the caller.
17004 */
17007{
17010
17012
17014 {
17018
17020
17021 /*
17022 * Must add collation if not default for the type, because CREATE OR
17023 * REPLACE VIEW won't change it
17024 */
17026 {
17027 CollInfo *coll;
17028
17030 if (coll)
17032 fmtQualifiedDumpable(coll));
17033 }
17034
17036 }
17037
17039}
17040
17041/*
17042 * dumpTableSchema
17043 * write the declaration (not data) of one user-defined table or view
17044 */
17045static void
17047{
17054 int numParents;
17055 TableInfo **parents;
17060 k;
17061
17062 /* We had better have loaded per-column details about this table */
17064
17067
17070 qrelname);
17071
17074
17075 /* Is it a table or a view? */
17077 {
17079
17080 /*
17081 * Note: keep this code in sync with the is_view case in dumpRule()
17082 */
17083
17085
17088 tbinfo->dobj.catId.oid);
17089
17091
17094 else
17095 {
17097 {
17101 }
17103 }
17106
17110 }
17112 {
17114 PGresult *res;
17116
17118
17121 tbinfo->dobj.catId.oid);
17122
17123 appendPQExpBuffer(query,
17124 "SELECT pg_catalog.pg_get_propgraphdef('%u'::pg_catalog.oid) AS pgdef",
17125 tbinfo->dobj.catId.oid);
17126
17128
17130 {
17133 tbinfo->dobj.name);
17134 else
17135 pg_fatal("query to obtain definition of property graph \"%s\" returned more than one definition",
17136 tbinfo->dobj.name);
17137 }
17138
17140
17143 tbinfo->dobj.name);
17144
17146
17147 PQclear(res);
17148 destroyPQExpBuffer(query);
17149
17151 }
17152 else
17153 {
17158
17159 /*
17160 * Set reltypename, and collect any relkind-specific data that we
17161 * didn't fetch during getTables().
17162 */
17164 {
17166 {
17168 PGresult *res;
17169
17171
17172 /* retrieve partition key definition */
17173 appendPQExpBuffer(query,
17174 "SELECT pg_get_partkeydef('%u')",
17175 tbinfo->dobj.catId.oid);
17178 PQclear(res);
17179 destroyPQExpBuffer(query);
17180 break;
17181 }
17183 {
17185 PGresult *res;
17188
17190
17191 /* retrieve name of foreign server and generic options */
17192 appendPQExpBuffer(query,
17193 "SELECT fs.srvname, "
17194 "pg_catalog.array_to_string(ARRAY("
17195 "SELECT pg_catalog.quote_ident(option_name) || "
17196 "' ' || pg_catalog.quote_literal(option_value) "
17197 "FROM pg_catalog.pg_options_to_table(ftoptions) "
17198 "ORDER BY option_name"
17199 "), E',\n ') AS ftoptions "
17200 "FROM pg_catalog.pg_foreign_table ft "
17201 "JOIN pg_catalog.pg_foreign_server fs "
17202 "ON (fs.oid = ft.ftserver) "
17203 "WHERE ft.ftrelid = '%u'",
17204 tbinfo->dobj.catId.oid);
17210 PQclear(res);
17211 destroyPQExpBuffer(query);
17212
17214 break;
17215 }
17218 break;
17219 default:
17221 break;
17222 }
17223
17224 numParents = tbinfo->numParents;
17226
17229 tbinfo->dobj.catId.oid);
17230
17231 /*
17232 * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
17233 * ignore it when dumping if it was set in this case.
17234 */
17238 "UNLOGGED " : "",
17239 reltypename,
17240 qualrelname);
17241
17242 /*
17243 * Attach to type, if reloftype; except in case of a binary upgrade,
17244 * we dump the table normally and attach it to the type afterward.
17245 */
17249 zeroIsError));
17250
17252 {
17253 /* Dump the attributes */
17254 actual_atts = 0;
17256 {
17257 /*
17258 * Normally, dump if it's locally defined in this table, and
17259 * not dropped. But for binary upgrade, we'll dump all the
17260 * columns, and then fix up the dropped and nonlocal cases
17261 * below.
17262 */
17264 {
17267
17268 /*
17269 * Default value --- suppress if to be printed separately
17270 * or not at all.
17271 */
17275
17276 /*
17277 * Not Null constraint --- print it if it is locally
17278 * defined, or if binary upgrade. (In the latter case, we
17279 * reset conislocal below.)
17280 */
17283 dopt->binary_upgrade ||
17284 tbinfo->ispartition));
17285
17286 /*
17287 * Skip column if fully defined by reloftype, except in
17288 * binary upgrade
17289 */
17292 !dopt->binary_upgrade)
17293 continue;
17294
17295 /* Format properly if not first attr */
17298 else
17301 actual_atts++;
17302
17303 /* Attribute name */
17305
17307 {
17308 /*
17309 * ALTER TABLE DROP COLUMN clears
17310 * pg_attribute.atttypid, so we will not have gotten a
17311 * valid type name; insert INTEGER as a stopgap. We'll
17312 * clean things up later.
17313 */
17315 /* and skip to the next column */
17316 continue;
17317 }
17318
17319 /*
17320 * Attribute type; print it except when creating a typed
17321 * table ('OF type_name'), but in binary-upgrade mode,
17322 * print it in that case too.
17323 */
17325 {
17328 }
17329
17331 {
17338 else
17341 }
17342
17344 {
17347 else
17350
17353 }
17354
17355 /* Add collation if not default for the type */
17357 {
17358 CollInfo *coll;
17359
17361 if (coll)
17363 fmtQualifiedDumpable(coll));
17364 }
17365 }
17366
17367 /*
17368 * On the other hand, if we choose not to print a column
17369 * (likely because it is created by inheritance), but the
17370 * column has a locally-defined not-null constraint, we need
17371 * to dump the constraint as a standalone object.
17372 *
17373 * This syntax isn't SQL-conforming, but if you wanted
17374 * standard output you wouldn't be creating non-standard
17375 * objects to begin with.
17376 */
17381 {
17382 /* Format properly if not first attr */
17385 else
17388 actual_atts++;
17389
17393 else
17397
17400 }
17401 }
17402
17403 /*
17404 * Add non-inherited CHECK constraints, if any.
17405 *
17406 * For partitions, we need to include check constraints even if
17407 * they're not defined locally, because the ALTER TABLE ATTACH
17408 * PARTITION that we'll emit later expects the constraint to be
17409 * there. (No need to fix conislocal: ATTACH PARTITION does that)
17410 */
17412 {
17414
17417 continue;
17418
17421 else
17423
17427
17428 actual_atts++;
17429 }
17430
17434 {
17435 /*
17436 * No attributes? we must have a parenthesized attribute list,
17437 * even though empty, when not using the OF TYPE syntax.
17438 */
17440 }
17441
17442 /*
17443 * Emit the INHERITS clause (not for partitions), except in
17444 * binary-upgrade mode.
17445 */
17447 !dopt->binary_upgrade)
17448 {
17450 for (k = 0; k < numParents; k++)
17451 {
17453
17454 if (k > 0)
17457 }
17459 }
17460
17463
17466 }
17467
17470 {
17472
17475 {
17478 }
17480 {
17484 fout);
17485 }
17487 }
17488
17489 /* Dump generic options if any */
17492
17493 /*
17494 * For materialized views, create the AS clause just like a view. At
17495 * this point, we always mark the view as not populated.
17496 */
17498 {
17500
17503 result->data);
17505 }
17506 else
17508
17509 /* Materialized views can depend on extensions */
17512 "pg_catalog.pg_class",
17513 "MATERIALIZED VIEW",
17514 qualrelname);
17515
17516 /*
17517 * in binary upgrade mode, update the catalog with any missing values
17518 * that might be present.
17519 */
17521 {
17523 {
17525 {
17527 appendPQExpBufferStr(q,
17528 "SELECT pg_catalog.binary_upgrade_set_missing_value(");
17535 }
17536 }
17537 }
17538
17539 /*
17540 * To create binary-compatible heap files, we have to ensure the same
17541 * physical column order, including dropped columns, as in the
17542 * original. Therefore, we create dropped columns above and drop them
17543 * here, also updating their attlen/attalign values so that the
17544 * dropped column can be skipped properly. (We do not bother with
17545 * restoring the original attbyval setting.) Also, inheritance
17546 * relationships are set up by doing ALTER TABLE INHERIT rather than
17547 * using an INHERITS clause --- the latter would possibly mess up the
17548 * column order. That also means we have to take care about setting
17549 * attislocal correctly, plus fix up any inherited CHECK constraints.
17550 * Analogously, we set up typed tables using ALTER TABLE / OF here.
17551 *
17552 * We process foreign and partitioned tables here, even though they
17553 * lack heap storage, because they can participate in inheritance
17554 * relationships and we want this stuff to be consistent across the
17555 * inheritance tree. We can exclude indexes, toast tables, sequences
17556 * and matviews, even though they have storage, because we don't
17557 * support altering or dropping columns in them, nor can they be part
17558 * of inheritance trees.
17559 */
17564 {
17567
17568 /*
17569 * Drop any dropped columns. Merge the pg_attribute manipulations
17570 * into a single SQL command, so that we don't cause repeated
17571 * relcache flushes on the target table. Otherwise we risk O(N^2)
17572 * relcache bloat while dropping N columns.
17573 */
17574 resetPQExpBuffer(extra);
17577 {
17579 {
17581 {
17583 "UPDATE pg_catalog.pg_attribute\n"
17584 "SET attlen = v.dlen, "
17585 "attalign = v.dalign, "
17586 "attbyval = false\n"
17587 "FROM (VALUES ");
17589 }
17590 else
17597 /* The ALTER ... DROP COLUMN commands must come after */
17602 }
17603 }
17605 {
17607 "WHERE attrelid = ");
17610 " AND attname = v.dname;\n");
17611 /* Now we can issue the actual DROP COLUMN commands */
17613 }
17614
17615 /*
17616 * Fix up inherited columns. As above, do the pg_attribute
17617 * manipulations in a single SQL command.
17618 */
17621 {
17624 {
17626 {
17629 "SET attislocal = false\n"
17630 "WHERE attrelid = ");
17633 " AND attname IN (");
17635 }
17636 else
17639 }
17640 }
17643
17644 /*
17645 * Fix up not-null constraints that come from inheritance. As
17646 * above, do the pg_constraint manipulations in a single SQL
17647 * command. (Actually, two in special cases, if we're doing an
17648 * upgrade from < 18).
17649 */
17652 resetPQExpBuffer(extra);
17654 {
17655 /*
17656 * If a not-null constraint comes from inheritance, reset
17657 * conislocal. The inhcount is fixed by ALTER TABLE INHERIT,
17658 * below. Special hack: in versions < 18, columns with no
17659 * local definition need their constraint to be matched by
17660 * column number in conkeys instead of by constraint name,
17661 * because the latter is not available. (We distinguish the
17662 * case because the constraint name is the empty string.)
17663 */
17666 {
17668 {
17670 {
17672 "SET conislocal = false\n"
17673 "WHERE contype = 'n' AND conrelid = ");
17676 "conname IN (");
17678 }
17679 else
17682 }
17683 else
17684 {
17686 {
17688 "SET conislocal = false\n"
17689 "WHERE contype = 'n' AND conrelid = ");
17692 "conkey IN (");
17694 }
17695 else
17698 }
17699 }
17700 }
17705
17708
17709 /*
17710 * Add inherited CHECK constraints, if any.
17711 *
17712 * For partitions, they were already dumped, and conislocal
17713 * doesn't need fixing.
17714 *
17715 * As above, issue only one direct manipulation of pg_constraint.
17716 * Although it is tempting to merge the ALTER ADD CONSTRAINT
17717 * commands into one as well, refrain for now due to concern about
17718 * possible backend memory bloat if there are many such
17719 * constraints.
17720 */
17721 resetPQExpBuffer(extra);
17724 {
17726
17728 continue;
17729
17735 constr->condef);
17736 /* Update pg_constraint after all the ALTER TABLEs */
17738 {
17740 "SET conislocal = false\n"
17741 "WHERE contype = 'c' AND conrelid = ");
17746 }
17747 else
17750 }
17752 {
17755 }
17756
17758 {
17760 for (k = 0; k < numParents; k++)
17761 {
17763
17765 qualrelname,
17767 }
17768 }
17769
17771 {
17774 qualrelname,
17776 zeroIsError));
17777 }
17778 }
17779
17780 /*
17781 * In binary_upgrade mode, arrange to restore the old relfrozenxid and
17782 * relminmxid of all vacuumable relations. (While vacuum.c processes
17783 * TOAST tables semi-independently, here we see them only as children
17784 * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
17785 * child toast table is handled below.)
17786 */
17790 {
17793 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17794 "WHERE oid = ",
17798
17800 {
17801 /*
17802 * The toast table will have the same OID at restore, so we
17803 * can safely target it by OID.
17804 */
17805 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
17807 "SET relfrozenxid = '%u', relminmxid = '%u'\n"
17808 "WHERE oid = '%u';\n",
17809 tbinfo->toast_frozenxid,
17811 }
17812 }
17813
17814 /*
17815 * In binary_upgrade mode, restore matviews' populated status by
17816 * poking pg_class directly. This is pretty ugly, but we can't use
17817 * REFRESH MATERIALIZED VIEW since it's possible that some underlying
17818 * matview is not populated even though this matview is; in any case,
17819 * we want to transfer the matview's heap storage, not run REFRESH.
17820 */
17822 tbinfo->relispopulated)
17823 {
17826 "SET relispopulated = 't'\n"
17827 "WHERE oid = ");
17830 }
17831
17832 /*
17833 * Dump additional per-column properties that we can't handle in the
17834 * main CREATE TABLE command.
17835 */
17837 {
17838 /* None of this applies to dropped columns */
17840 continue;
17841
17842 /*
17843 * Dump per-column statistics information. We only issue an ALTER
17844 * TABLE statement if the attstattarget entry for this column is
17845 * not the default value.
17846 */
17852
17853 /*
17854 * Dump per-column storage information. The statement is only
17855 * dumped if the storage has been changed from the type's default.
17856 */
17858 {
17860 {
17863 break;
17866 break;
17869 break;
17872 break;
17873 default:
17875 }
17876
17877 /*
17878 * Only dump the statement if it's a storage type we recognize
17879 */
17884 storage);
17885 }
17886
17887 /*
17888 * Dump per-column compression, if it's been set.
17889 */
17891 {
17893
17895 {
17896 case 'p':
17898 break;
17899 case 'l':
17901 break;
17902 default:
17904 break;
17905 }
17906
17911 cmname);
17912 }
17913
17914 /*
17915 * Dump per-column attributes.
17916 */
17922
17923 /*
17924 * Dump per-column fdw options.
17925 */
17928 appendPQExpBuffer(q,
17929 "ALTER FOREIGN TABLE ONLY %s ALTER COLUMN %s OPTIONS (\n"
17930 " %s\n"
17931 ");\n",
17932 qualrelname,
17935 } /* end loop over columns */
17936
17940 }
17941
17942 /*
17943 * dump properties we only have ALTER TABLE syntax for
17944 */
17949 {
17951 {
17952 /* nothing to do, will be set when the index is dumped */
17953 }
17955 {
17957 qualrelname);
17958 }
17960 {
17962 qualrelname);
17963 }
17964 }
17965
17968 qualrelname);
17969
17971
17975 tbinfo->dobj.namespace->dobj.name);
17976
17978 {
17981
17982 /*
17983 * _selectTablespace() relies on tablespace-enabled objects in the
17984 * default tablespace to have a tablespace of "" (empty string) versus
17985 * non-tablespace-enabled objects to have a tablespace of NULL.
17986 * getTables() sets tbinfo->reltablespace to "" for the default
17987 * tablespace (not NULL).
17988 */
17991
17994 tableam = tbinfo->amname;
17995
17998 .namespace = tbinfo->dobj.namespace->dobj.name,
17999 .tablespace = tablespace,
18000 .tableam = tableam,
18001 .relkind = tbinfo->relkind,
18002 .owner = tbinfo->rolname,
18003 .description = reltypename,
18004 .section = tbinfo->postponed_def ?
18006 .createStmt = q->data,
18008 }
18009
18010 /* Dump Table Comments */
18013
18014 /* Dump Table Security Labels */
18017
18018 /*
18019 * Dump comments for not-null constraints that aren't to be dumped
18020 * separately (those are processed by collectComments/dumpComment).
18021 */
18023 fout->remoteVersion >= 180000)
18024 {
18027
18029 {
18032 {
18034 {
18036 tag = createPQExpBuffer();
18037 }
18038 else
18039 {
18041 resetPQExpBuffer(tag);
18042 }
18043
18048
18051
18054 .namespace = tbinfo->dobj.namespace->dobj.name,
18055 .owner = tbinfo->rolname,
18056 .description = "COMMENT",
18057 .section = SECTION_NONE,
18058 .createStmt = comment->data,
18059 .deps = &(tbinfo->dobj.dumpId),
18060 .nDeps = 1));
18061 }
18062 }
18063
18065 destroyPQExpBuffer(tag);
18066 }
18067
18068 /* Dump comments on inlined table constraints */
18070 {
18072
18074 continue;
18075
18078 }
18079
18080 destroyPQExpBuffer(q);
18082 destroyPQExpBuffer(extra);
18085}
18086
18087/*
18088 * dumpTableAttach
18089 * write to fout the commands to attach a child partition
18090 *
18091 * Child partitions are always made by creating them separately
18092 * and then using ATTACH PARTITION, rather than using
18093 * CREATE TABLE ... PARTITION OF. This is important for preserving
18094 * any possible discrepancy in column layout, to allow assigning the
18095 * correct tablespace if different, and so that it's possible to restore
18096 * a partition without restoring its parent. (You'll get an error from
18097 * the ATTACH PARTITION command, but that can be ignored, or skipped
18098 * using "pg_restore -L" if you prefer.) The last point motivates
18099 * treating ATTACH PARTITION as a completely separate ArchiveEntry
18100 * rather than emitting it within the child partition's ArchiveEntry.
18101 */
18102static void
18104{
18106 PQExpBuffer q;
18107 PGresult *res;
18108 char *partbound;
18109
18110 /* Do nothing if not dumping schema */
18112 return;
18113
18114 q = createPQExpBuffer();
18115
18117 {
18118 /* Set up query for partbound details */
18119 appendPQExpBufferStr(q,
18120 "PREPARE dumpTableAttach(pg_catalog.oid) AS\n");
18121
18122 appendPQExpBufferStr(q,
18123 "SELECT pg_get_expr(c.relpartbound, c.oid) "
18124 "FROM pg_class c "
18125 "WHERE c.oid = $1");
18126
18128
18130 }
18131
18132 printfPQExpBuffer(q,
18133 "EXECUTE dumpTableAttach('%u')",
18134 attachinfo->partitionTbl->dobj.catId.oid);
18135
18137 partbound = PQgetvalue(res, 0, 0);
18138
18139 /* Perform ALTER TABLE on the parent */
18140 printfPQExpBuffer(q,
18141 "ALTER TABLE ONLY %s ",
18143 appendPQExpBuffer(q,
18144 "ATTACH PARTITION %s %s;\n",
18146 partbound);
18147
18148 /*
18149 * There is no point in creating a drop query as the drop is done by table
18150 * drop. (If you think to change this, see also _printTocEntry().)
18151 * Although this object doesn't really have ownership as such, set the
18152 * owner field anyway to ensure that the command is run by the correct
18153 * role at restore time.
18154 */
18157 .namespace = attachinfo->dobj.namespace->dobj.name,
18158 .owner = attachinfo->partitionTbl->rolname,
18159 .description = "TABLE ATTACH",
18160 .section = SECTION_PRE_DATA,
18161 .createStmt = q->data));
18162
18163 PQclear(res);
18164 destroyPQExpBuffer(q);
18165}
18166
18167/*
18168 * dumpAttrDef --- dump an attribute's default-value declaration
18169 */
18170static void
18172{
18176 PQExpBuffer q;
18179 char *tag;
18181
18182 /* Do nothing if not dumping schema */
18184 return;
18185
18186 /* Skip if not "separate"; it was dumped in the table's definition */
18188 return;
18189
18190 q = createPQExpBuffer();
18192
18194
18196
18197 appendPQExpBuffer(q,
18198 "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
18200 adinfo->adef_expr);
18201
18205
18207
18210 ARCHIVE_OPTS(.tag = tag,
18212 .owner = tbinfo->rolname,
18213 .description = "DEFAULT",
18214 .section = SECTION_PRE_DATA,
18215 .createStmt = q->data,
18216 .dropStmt = delq->data));
18217
18218 pfree(tag);
18219 destroyPQExpBuffer(q);
18222}
18223
18224/*
18225 * getAttrName: extract the correct name for an attribute
18226 *
18227 * The array tblInfo->attnames[] only provides names of user attributes;
18228 * if a system attribute number is supplied, we have to fake it.
18229 * We also do a little bit of bounds checking for safety's sake.
18230 */
18231static const char *
18233{
18236 switch (attrnum)
18237 {
18239 return "ctid";
18241 return "xmin";
18243 return "cmin";
18245 return "xmax";
18247 return "cmax";
18249 return "tableoid";
18250 }
18252 attrnum, tblInfo->dobj.name);
18254}
18255
18256/*
18257 * dumpIndex
18258 * write out to fout a user-defined index
18259 */
18260static void
18262{
18266 PQExpBuffer q;
18270
18271 /* Do nothing if not dumping schema */
18273 return;
18274
18275 q = createPQExpBuffer();
18277
18280
18281 /*
18282 * If there's an associated constraint, don't dump the index per se, but
18283 * do dump any comment for it. (This is safe because dependency ordering
18284 * will have ensured the constraint is emitted first.) Note that the
18285 * emitted comment has to be shown as depending on the constraint, not the
18286 * index, in such cases.
18287 */
18289 {
18296
18299 indxinfo->dobj.catId.oid);
18300
18301 /* Plain secondary index */
18303
18304 /*
18305 * Append ALTER TABLE commands as needed to set properties that we
18306 * only have ALTER TABLE syntax for. Keep this in sync with the
18307 * similar code in dumpConstraint!
18308 */
18309
18310 /* If the index is clustered, we need to record that. */
18312 {
18315 /* index name is not qualified in this syntax */
18317 qindxname);
18318 }
18319
18320 /*
18321 * If the index has any statistics on some of its columns, generate
18322 * the associated ALTER INDEX queries.
18323 */
18325 {
18327
18334
18336 {
18338
18339 /*
18340 * Note that this is a column number, so no quotes should be
18341 * used.
18342 */
18347 }
18348 }
18349
18350 /* Indexes can depend on extensions */
18352 "pg_catalog.pg_class",
18354
18355 /* If the index defines identity, we need to record that. */
18357 {
18360 /* index name is not qualified in this syntax */
18362 qindxname);
18363 }
18364
18365 /*
18366 * If this index is a member of a partitioned index, the backend will
18367 * not allow us to drop it separately, so don't try. It will go away
18368 * automatically when we drop either the index's table or the
18369 * partitioned index. (If, in a selective restore with --clean, we
18370 * drop neither of those, then this index will not be dropped either.
18371 * But that's fine, and even if you think it's not, the backend won't
18372 * let us do differently.)
18373 */
18376
18380 .namespace = tbinfo->dobj.namespace->dobj.name,
18381 .tablespace = indxinfo->tablespace,
18382 .owner = tbinfo->rolname,
18383 .description = "INDEX",
18384 .section = SECTION_POST_DATA,
18385 .createStmt = q->data,
18386 .dropStmt = delq->data));
18387
18390 }
18391
18392 /* Dump Index Comments */
18395 tbinfo->dobj.namespace->dobj.name,
18396 tbinfo->rolname,
18397 indxinfo->dobj.catId, 0,
18399 indxinfo->dobj.dumpId);
18400
18401 destroyPQExpBuffer(q);
18405}
18406
18407/*
18408 * dumpIndexAttach
18409 * write out to fout a partitioned-index attachment clause
18410 */
18411static void
18413{
18414 /* Do nothing if not dumping schema */
18416 return;
18417
18419 {
18421
18426
18427 /*
18428 * There is no need for a dropStmt since the drop is done implicitly
18429 * when we drop either the index's table or the partitioned index.
18430 * Moreover, since there's no ALTER INDEX DETACH PARTITION command,
18431 * there's no way to do it anyway. (If you think to change this,
18432 * consider also what to do with --if-exists.)
18433 *
18434 * Although this object doesn't really have ownership as such, set the
18435 * owner field anyway to ensure that the command is run by the correct
18436 * role at restore time.
18437 */
18440 .namespace = attachinfo->dobj.namespace->dobj.name,
18441 .owner = attachinfo->parentIdx->indextable->rolname,
18442 .description = "INDEX ATTACH",
18443 .section = SECTION_POST_DATA,
18444 .createStmt = q->data));
18445
18446 destroyPQExpBuffer(q);
18447 }
18448}
18449
18450/*
18451 * dumpStatisticsExt
18452 * write out to fout an extended statistics object
18453 */
18454static void
18456{
18458 PQExpBuffer q;
18460 PQExpBuffer query;
18462 PGresult *res;
18464
18465 /* Do nothing if not dumping schema */
18467 return;
18468
18469 q = createPQExpBuffer();
18471 query = createPQExpBuffer();
18472
18474
18476 "pg_catalog.pg_get_statisticsobjdef('%u'::pg_catalog.oid)",
18477 statsextinfo->dobj.catId.oid);
18478
18480
18482
18483 /* Result of pg_get_statisticsobjdef is complete except for semicolon */
18485
18486 /*
18487 * We only issue an ALTER STATISTICS statement if the stxstattarget entry
18488 * for this statistics object is not the default value.
18489 */
18491 {
18495 statsextinfo->stattarget);
18496 }
18497
18500
18503 statsextinfo->dobj.dumpId,
18505 .namespace = statsextinfo->dobj.namespace->dobj.name,
18506 .owner = statsextinfo->rolname,
18507 .description = "STATISTICS",
18508 .section = SECTION_POST_DATA,
18509 .createStmt = q->data,
18510 .dropStmt = delq->data));
18511
18512 /* Dump Statistics Comments */
18515 statsextinfo->dobj.namespace->dobj.name,
18516 statsextinfo->rolname,
18517 statsextinfo->dobj.catId, 0,
18518 statsextinfo->dobj.dumpId);
18519
18520 PQclear(res);
18521 destroyPQExpBuffer(q);
18523 destroyPQExpBuffer(query);
18525}
18526
18527/*
18528 * dumpStatisticsExtStats
18529 * write out to fout the stats for an extended statistics object
18530 */
18531static void
18533{
18535 PQExpBuffer query;
18536 PGresult *res;
18537 int nstats;
18538
18539 /* Do nothing if not dumping statistics */
18541 return;
18542
18544 {
18546
18547 /*---------
18548 * Set up query for details about extended statistics objects.
18549 *
18550 * The query depends on the backend version:
18551 * - In v19 and newer versions, query directly the pg_stats_ext*
18552 * catalogs.
18553 * - In v18 and older versions, ndistinct and dependencies have a
18554 * different format that needs translation.
18555 * - In v14 and older versions, inherited does not exist.
18556 * - In v11 and older versions, there is no pg_stats_ext, hence
18557 * the logic joins pg_statistic_ext and pg_namespace.
18558 *---------
18559 */
18560
18562 "PREPARE getExtStatsStats(pg_catalog.name, pg_catalog.name) AS\n"
18563 "SELECT ");
18564
18565 /*
18566 * Versions 15 and newer have inherited stats.
18567 *
18568 * Create this column in all versions because we need to order by it
18569 * later.
18570 */
18573 else
18575
18576 /*--------
18577 * The ndistinct and dependencies formats changed in v19, so
18578 * everything before that needs to be translated.
18579 *
18580 * The ndistinct translation converts this kind of data:
18581 * {"3, 4": 11, "3, 6": 11, "4, 6": 11, "3, 4, 6": 11}
18582 *
18583 * to this:
18584 * [ {"attributes": [3,4], "ndistinct": 11},
18585 * {"attributes": [3,6], "ndistinct": 11},
18586 * {"attributes": [4,6], "ndistinct": 11},
18587 * {"attributes": [3,4,6], "ndistinct": 11} ]
18588 *
18589 * The dependencies translation converts this kind of data:
18590 * {"3 => 4": 1.000000, "3 => 6": 1.000000,
18591 * "4 => 6": 1.000000, "3, 4 => 6": 1.000000,
18592 * "3, 6 => 4": 1.000000}
18593 *
18594 * to this:
18595 * [ {"attributes": [3], "dependency": 4, "degree": 1.000000},
18596 * {"attributes": [3], "dependency": 6, "degree": 1.000000},
18597 * {"attributes": [4], "dependency": 6, "degree": 1.000000},
18598 * {"attributes": [3,4], "dependency": 6, "degree": 1.000000},
18599 * {"attributes": [3,6], "dependency": 4, "degree": 1.000000} ]
18600 *--------
18601 */
18604 else
18606 "( "
18607 "SELECT json_agg( "
18608 " json_build_object( "
18610 " string_to_array(kv.key, ', ')::integer[], "
18612 " kv.value::bigint )) "
18613 "FROM json_each_text(e.n_distinct::text::json) AS kv"
18614 ") AS n_distinct, "
18615 "( "
18616 "SELECT json_agg( "
18617 " json_build_object( "
18619 " string_to_array( "
18620 " split_part(kv.key, ' => ', 1), "
18621 " ', ')::integer[], "
18623 " split_part(kv.key, ' => ', 2)::integer, "
18625 " kv.value::double precision )) "
18626 "FROM json_each_text(e.dependencies::text::json) AS kv "
18627 ") AS dependencies, ");
18628
18629 /* MCV was introduced v13 */
18632 "e.most_common_vals, e.most_common_freqs, "
18633 "e.most_common_base_freqs, ");
18634 else
18636 "NULL AS most_common_vals, NULL AS most_common_freqs, "
18637 "NULL AS most_common_base_freqs, ");
18638
18639 /* Expressions were introduced in v14 */
18641 {
18642 /*
18643 * There is no ordering column in pg_stats_ext_exprs. However, we
18644 * can rely on the unnesting of pg_statistic_ext_data.stxdexpr to
18645 * maintain the desired order of expression elements.
18646 */
18648 "( "
18649 "SELECT jsonb_pretty(jsonb_agg("
18650 "nullif(j.obj, '{}'::jsonb))) "
18651 "FROM pg_stats_ext_exprs AS ee "
18652 "CROSS JOIN LATERAL jsonb_strip_nulls("
18653 " jsonb_build_object( "
18654 " 'null_frac', ee.null_frac::text, "
18655 " 'avg_width', ee.avg_width::text, "
18656 " 'n_distinct', ee.n_distinct::text, "
18657 " 'most_common_vals', ee.most_common_vals::text, "
18658 " 'most_common_freqs', ee.most_common_freqs::text, "
18659 " 'histogram_bounds', ee.histogram_bounds::text, "
18660 " 'correlation', ee.correlation::text, "
18661 " 'most_common_elems', ee.most_common_elems::text, "
18662 " 'most_common_elem_freqs', ee.most_common_elem_freqs::text, "
18663 " 'elem_count_histogram', ee.elem_count_histogram::text");
18664
18665 /* These three have been added to pg_stats_ext_exprs in v19. */
18668 ", "
18669 " 'range_length_histogram', ee.range_length_histogram::text, "
18670 " 'range_empty_frac', ee.range_empty_frac::text, "
18671 " 'range_bounds_histogram', ee.range_bounds_histogram::text");
18672
18674 " )) AS j(obj)"
18675 "WHERE ee.statistics_schemaname = $1 "
18676 "AND ee.statistics_name = $2 ");
18677 /* Inherited expressions introduced in v15 */
18680
18682 }
18683 else
18685
18686 /* pg_stats_ext introduced in v12 */
18689 "FROM pg_catalog.pg_stats_ext AS e "
18690 "WHERE e.statistics_schemaname = $1 "
18691 "AND e.statistics_name = $2 ");
18692 else
18694 "FROM ( "
18695 "SELECT s.stxndistinct AS n_distinct, "
18696 " s.stxdependencies AS dependencies "
18697 "FROM pg_catalog.pg_statistic_ext AS s "
18698 "JOIN pg_catalog.pg_namespace AS n "
18699 "ON n.oid = s.stxnamespace "
18700 "WHERE n.nspname = $1 "
18701 "AND s.stxname = $2 "
18702 ") AS e ");
18703
18704 /* we always have an inherited column, but it may be a constant */
18706
18708
18710
18712 }
18713
18714 query = createPQExpBuffer();
18715
18721
18723
18724 destroyPQExpBuffer(query);
18725
18726 nstats = PQntuples(res);
18727
18728 if (nstats > 0)
18729 {
18731
18739
18741 {
18743
18746
18747 appendPQExpBufferStr(out,
18748 "SELECT * FROM pg_catalog.pg_restore_extended_stats(\n");
18750 fout->remoteVersion);
18751
18752 /* Relation information */
18757
18758 /* Extended statistics information */
18765
18769
18773
18777
18781
18785
18789
18791 }
18792
18795 .namespace = statsextinfo->dobj.namespace->dobj.name,
18796 .owner = statsextinfo->rolname,
18797 .description = "EXTENDED STATISTICS DATA",
18798 .section = SECTION_POST_DATA,
18799 .createStmt = out->data,
18800 .deps = &statsextinfo->dobj.dumpId,
18801 .nDeps = 1));
18802 destroyPQExpBuffer(out);
18803 }
18804 PQclear(res);
18805}
18806
18807/*
18808 * dumpConstraint
18809 * write out to fout a user-defined constraint
18810 */
18811static void
18813{
18816 PQExpBuffer q;
18820
18821 /* Do nothing if not dumping schema */
18823 return;
18824
18825 q = createPQExpBuffer();
18827
18830
18834 {
18835 /* Index-related constraint */
18837 int k;
18838
18840
18843 coninfo->dobj.name);
18844
18847 indxinfo->dobj.catId.oid);
18848
18853
18855 {
18856 /* pg_get_constraintdef should have provided everything */
18858 }
18859 else
18860 {
18861 appendPQExpBufferStr(q,
18863
18864 /*
18865 * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
18866 * indexes. Being able to create this was fixed, but we need to
18867 * make the index distinct in order to be able to restore the
18868 * dump.
18869 */
18874 {
18877
18879 break;
18881
18883 (k == 0) ? "" : ", ",
18885 }
18888
18891
18893 {
18896
18898 break;
18900
18904 }
18905
18907
18909 {
18913 }
18914
18916 {
18920 }
18921
18923 }
18924
18925 /*
18926 * Append ALTER TABLE commands as needed to set properties that we
18927 * only have ALTER TABLE syntax for. Keep this in sync with the
18928 * similar code in dumpIndex!
18929 */
18930
18931 /* If the index is clustered, we need to record that. */
18933 {
18936 /* index name is not qualified in this syntax */
18939 }
18940
18941 /* If the index defines identity, we need to record that. */
18943 {
18946 /* index name is not qualified in this syntax */
18949 }
18950
18951 /* Indexes can depend on extensions */
18953 "pg_catalog.pg_class", "INDEX",
18955
18960
18962
18965 ARCHIVE_OPTS(.tag = tag,
18967 .tablespace = indxinfo->tablespace,
18968 .owner = tbinfo->rolname,
18969 .description = "CONSTRAINT",
18970 .section = SECTION_POST_DATA,
18971 .createStmt = q->data,
18972 .dropStmt = delq->data));
18973 }
18975 {
18977
18978 /*
18979 * Foreign keys on partitioned tables are always declared as
18980 * inheriting to partitions; for all other cases, emit them as
18981 * applying ONLY directly to the named table, because that's how they
18982 * work for regular inherited tables.
18983 */
18985
18986 /*
18987 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
18988 * current table data is not processed
18989 */
18994 coninfo->condef);
18995
19000
19002
19005 ARCHIVE_OPTS(.tag = tag,
19007 .owner = tbinfo->rolname,
19008 .description = "FK CONSTRAINT",
19009 .section = SECTION_POST_DATA,
19010 .createStmt = q->data,
19011 .dropStmt = delq->data));
19012 }
19014 {
19015 /* CHECK or invalid not-null constraint on a table */
19016
19017 /* Ignore if not to be dumped separately, or if it was inherited */
19019 {
19020 const char *keyword;
19021
19023 keyword = "CHECK CONSTRAINT";
19024 else
19025 keyword = "CONSTRAINT";
19026
19027 /* not ONLY since we want it to propagate to children */
19032 coninfo->condef);
19033
19038
19040
19043 ARCHIVE_OPTS(.tag = tag,
19045 .owner = tbinfo->rolname,
19046 .description = keyword,
19047 .section = SECTION_POST_DATA,
19048 .createStmt = q->data,
19049 .dropStmt = delq->data));
19050 }
19051 }
19053 {
19054 /* CHECK, NOT NULL constraint on a domain */
19056
19058
19059 /* Ignore if not to be dumped separately */
19061 {
19062 const char *keyword;
19063
19065 keyword = "CHECK CONSTRAINT";
19066 else
19067 keyword = "CONSTRAINT";
19068
19073 coninfo->condef);
19074
19079
19081
19084 ARCHIVE_OPTS(.tag = tag,
19086 .owner = tyinfo->rolname,
19087 .description = keyword,
19088 .section = SECTION_POST_DATA,
19089 .createStmt = q->data,
19090 .dropStmt = delq->data));
19091
19093 {
19096
19099
19101 tyinfo->dobj.namespace->dobj.name,
19102 tyinfo->rolname,
19106 }
19107 }
19108 }
19109 else
19110 {
19112 coninfo->contype);
19113 }
19114
19115 /* Dump Constraint Comments --- only works for table constraints */
19119
19120 pfree(tag);
19121 destroyPQExpBuffer(q);
19123}
19124
19125/*
19126 * dumpTableConstraintComment --- dump a constraint's comment if any
19127 *
19128 * This is split out because we need the function in two different places
19129 * depending on whether the constraint is dumped as part of CREATE TABLE
19130 * or as a separate ALTER command.
19131 */
19132static void
19134{
19138
19140
19143
19146 tbinfo->dobj.namespace->dobj.name,
19147 tbinfo->rolname,
19148 coninfo->dobj.catId, 0,
19150
19153}
19154
19157{
19159 {
19162 }
19163
19166}
19167
19168/*
19169 * bsearch() comparator for SequenceItem
19170 */
19171static int
19173{
19176
19178}
19179
19180/*
19181 * collectSequences
19182 *
19183 * Construct a table of sequence information. This table is sorted by OID for
19184 * speed in lookup.
19185 */
19186static void
19188{
19189 PGresult *res;
19190 const char *query;
19191
19192 /*
19193 * Since version 18, we can gather the sequence data in this query with
19194 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19195 */
19198 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19199 "seqstart, seqincrement, "
19200 "seqmax, seqmin, "
19201 "seqcache, seqcycle, "
19202 "NULL, 'f' "
19203 "FROM pg_catalog.pg_sequence "
19204 "ORDER BY seqrelid";
19205 else
19206 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19207 "seqstart, seqincrement, "
19208 "seqmax, seqmin, "
19209 "seqcache, seqcycle, "
19210 "last_value, is_called "
19211 "FROM pg_catalog.pg_sequence, "
19212 "pg_get_sequence_data(seqrelid) "
19213 "ORDER BY seqrelid;";
19214
19216
19219
19221 {
19233 }
19234
19235 PQclear(res);
19236}
19237
19238/*
19239 * dumpSequence
19240 * write the declaration (not data) of one user-defined sequence
19241 */
19242static void
19244{
19249 default_maxv;
19255
19257
19258 /*
19259 * The sequence information is gathered in a sorted table before any calls
19260 * to dumpSequence(). See collectSequences() for more information.
19261 */
19263
19267
19268 /* Calculate default limits for a sequence of this type */
19271 {
19274 }
19276 {
19279 }
19281 {
19284 }
19285 else
19286 {
19289 }
19290
19291 /*
19292 * Identity sequences are not to be dropped separately.
19293 */
19295 {
19298 }
19299
19300 resetPQExpBuffer(query);
19301
19303 {
19305 tbinfo->dobj.catId.oid);
19306
19307 /*
19308 * In older PG versions a sequence will have a pg_type entry, but v14
19309 * and up don't use that, so don't attempt to preserve the type OID.
19310 */
19311 }
19312
19314 {
19316
19317 appendPQExpBuffer(query,
19318 "ALTER TABLE %s ",
19319 fmtQualifiedDumpable(owning_tab));
19320 appendPQExpBuffer(query,
19321 "ALTER COLUMN %s ADD GENERATED ",
19329
19330 /*
19331 * Emit persistence option only if it's different from the owning
19332 * table's. This avoids using this new syntax unnecessarily.
19333 */
19337 "UNLOGGED" : "LOGGED");
19338 }
19339 else
19340 {
19341 appendPQExpBuffer(query,
19342 "CREATE %sSEQUENCE %s\n",
19344 "UNLOGGED " : "",
19346
19349 }
19350
19352
19354
19357 else
19359
19362 else
19364
19365 appendPQExpBuffer(query,
19368
19371 else
19373
19374 /* binary_upgrade: no need to clear TOAST table oid */
19375
19379 tbinfo->dobj.namespace->dobj.name);
19380
19384 .namespace = tbinfo->dobj.namespace->dobj.name,
19385 .owner = tbinfo->rolname,
19386 .description = "SEQUENCE",
19387 .section = SECTION_PRE_DATA,
19388 .createStmt = query->data,
19389 .dropStmt = delqry->data));
19390
19391 /*
19392 * If the sequence is owned by a table column, emit the ALTER for it as a
19393 * separate TOC entry immediately following the sequence's own entry. It's
19394 * OK to do this rather than using full sorting logic, because the
19395 * dependency that tells us it's owned will have forced the table to be
19396 * created first. We can't just include the ALTER in the TOC entry
19397 * because it will fail if we haven't reassigned the sequence owner to
19398 * match the table's owner.
19399 *
19400 * We need not schema-qualify the table reference because both sequence
19401 * and table must be in the same schema.
19402 */
19404 {
19406
19410
19412 {
19413 resetPQExpBuffer(query);
19417 fmtQualifiedDumpable(owning_tab));
19420
19424 .namespace = tbinfo->dobj.namespace->dobj.name,
19425 .owner = tbinfo->rolname,
19426 .description = "SEQUENCE OWNED BY",
19427 .section = SECTION_PRE_DATA,
19428 .createStmt = query->data,
19429 .deps = &(tbinfo->dobj.dumpId),
19430 .nDeps = 1));
19431 }
19432 }
19433
19434 /* Dump Sequence Comments and Security Labels */
19439
19444
19445 destroyPQExpBuffer(query);
19448}
19449
19450/*
19451 * dumpSequenceData
19452 * write the data of one user-defined sequence
19453 */
19454static void
19456{
19458 int64 last;
19460 PQExpBuffer query;
19461
19462 /* needn't bother if not dumping sequence data */
19464 return;
19465
19466 query = createPQExpBuffer();
19467
19468 /*
19469 * For versions >= 18, the sequence information is gathered in the sorted
19470 * array before any calls to dumpSequenceData(). See collectSequences()
19471 * for more information.
19472 *
19473 * For older versions, we have to query the sequence relations
19474 * individually.
19475 */
19477 {
19478 PGresult *res;
19479
19480 appendPQExpBuffer(query,
19481 "SELECT last_value, is_called FROM %s",
19483
19485
19488 "query to get data of sequence \"%s\" returned %d rows (expected 1)",
19489 PQntuples(res)),
19491
19494
19495 PQclear(res);
19496 }
19497 else
19498 {
19500 SequenceItem *entry;
19501
19504
19508
19511 "SELECT privilege on the sequence or the sequence may "
19512 "have been concurrently dropped",
19513 tbinfo->dobj.name);
19514
19515 last = entry->last_value;
19517 }
19518
19519 resetPQExpBuffer(query);
19524
19528 .namespace = tbinfo->dobj.namespace->dobj.name,
19529 .owner = tbinfo->rolname,
19530 .description = "SEQUENCE SET",
19531 .section = SECTION_DATA,
19532 .createStmt = query->data,
19533 .deps = &(tbinfo->dobj.dumpId),
19534 .nDeps = 1));
19535
19536 destroyPQExpBuffer(query);
19537}
19538
19539/*
19540 * dumpTrigger
19541 * write the declaration of one user-defined table trigger
19542 */
19543static void
19545{
19548 PQExpBuffer query;
19553 char *tag;
19554
19555 /* Do nothing if not dumping schema */
19557 return;
19558
19559 query = createPQExpBuffer();
19563
19565
19568
19571
19572 /* Triggers can depend on extensions */
19574 "pg_catalog.pg_trigger", "TRIGGER",
19575 trigidentity->data);
19576
19578 {
19580
19581 /*
19582 * Partition triggers only appear here because their 'tgenabled' flag
19583 * differs from its parent's. The trigger is created already, so
19584 * remove the CREATE and replace it with an ALTER. (Clear out the
19585 * DROP query too, so that pg_dump --create does not cause errors.)
19586 */
19587 resetPQExpBuffer(query);
19593 {
19594 case 'f':
19595 case 'D':
19597 break;
19598 case 't':
19599 case 'O':
19601 break;
19602 case 'R':
19604 break;
19605 case 'A':
19607 break;
19608 }
19611 }
19613 {
19618 {
19619 case 'D':
19620 case 'f':
19622 break;
19623 case 'A':
19625 break;
19626 case 'R':
19628 break;
19629 default:
19631 break;
19632 }
19635 }
19636
19639
19641
19644 ARCHIVE_OPTS(.tag = tag,
19646 .owner = tbinfo->rolname,
19647 .description = "TRIGGER",
19648 .section = SECTION_POST_DATA,
19649 .createStmt = query->data,
19650 .dropStmt = delqry->data));
19651
19656
19657 pfree(tag);
19658 destroyPQExpBuffer(query);
19663}
19664
19665/*
19666 * dumpEventTrigger
19667 * write the declaration of one user-defined event trigger
19668 */
19669static void
19671{
19673 PQExpBuffer query;
19676
19677 /* Do nothing if not dumping schema */
19679 return;
19680
19681 query = createPQExpBuffer();
19683
19685
19690
19692 {
19696 }
19697
19701
19703 {
19705 qevtname);
19707 {
19708 case 'D':
19710 break;
19711 case 'A':
19713 break;
19714 case 'R':
19716 break;
19717 default:
19719 break;
19720 }
19722 }
19723
19725 qevtname);
19726
19730
19734 .owner = evtinfo->evtowner,
19735 .description = "EVENT TRIGGER",
19736 .section = SECTION_POST_DATA,
19737 .createStmt = query->data,
19738 .dropStmt = delqry->data));
19739
19744
19749
19750 destroyPQExpBuffer(query);
19753}
19754
19755/*
19756 * dumpRule
19757 * Dump a rule
19758 */
19759static void
19761{
19765 PQExpBuffer query;
19766 PQExpBuffer cmd;
19770 PGresult *res;
19771 char *tag;
19772
19773 /* Do nothing if not dumping schema */
19775 return;
19776
19777 /*
19778 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
19779 * we do not want to dump it as a separate object.
19780 */
19782 return;
19783
19784 /*
19785 * If it's an ON SELECT rule, we want to print it as a view definition,
19786 * instead of a rule.
19787 */
19789
19790 query = createPQExpBuffer();
19791 cmd = createPQExpBuffer();
19794
19796
19798 {
19800
19801 /*
19802 * We need OR REPLACE here because we'll be replacing a dummy view.
19803 * Otherwise this should look largely like the regular view dump code.
19804 */
19808 {
19812 }
19818 tbinfo->checkoption);
19820 }
19821 else
19822 {
19823 /* In the rule case, just print pg_get_ruledef's result verbatim */
19824 appendPQExpBuffer(query,
19825 "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid)",
19827
19829
19833
19835
19836 PQclear(res);
19837 }
19838
19839 /*
19840 * Add the command to alter the rules replication firing semantics if it
19841 * differs from the default.
19842 */
19844 {
19847 {
19848 case 'A':
19851 break;
19852 case 'R':
19855 break;
19856 case 'D':
19859 break;
19860 }
19861 }
19862
19864 {
19865 /*
19866 * We can't DROP a view's ON SELECT rule. Instead, use CREATE OR
19867 * REPLACE VIEW to replace the rule with something with minimal
19868 * dependencies.
19869 */
19871
19877 }
19878 else
19879 {
19884 }
19885
19888
19890
19893 ARCHIVE_OPTS(.tag = tag,
19895 .owner = tbinfo->rolname,
19896 .description = "RULE",
19897 .section = SECTION_POST_DATA,
19898 .createStmt = cmd->data,
19899 .dropStmt = delcmd->data));
19900
19901 /* Dump rule comments */
19904 tbinfo->dobj.namespace->dobj.name,
19905 tbinfo->rolname,
19907
19908 pfree(tag);
19909 destroyPQExpBuffer(query);
19910 destroyPQExpBuffer(cmd);
19914}
19915
19916/*
19917 * getExtensionMembership --- obtain extension membership data
19918 *
19919 * We need to identify objects that are extension members as soon as they're
19920 * loaded, so that we can correctly determine whether they need to be dumped.
19921 * Generally speaking, extension member objects will get marked as *not* to
19922 * be dumped, as they will be recreated by the single CREATE EXTENSION
19923 * command. However, in binary upgrade mode we still need to dump the members
19924 * individually.
19925 */
19926void
19929{
19930 PQExpBuffer query;
19931 PGresult *res;
19932 int ntups,
19933 i;
19935 i_objid,
19936 i_refobjid;
19937 ExtensionInfo *ext;
19938
19939 /* Nothing to do if no extensions */
19941 return;
19942
19943 query = createPQExpBuffer();
19944
19945 /* refclassid constraint is redundant but may speed the search */
19947 "classid, objid, refobjid "
19948 "FROM pg_depend "
19949 "WHERE refclassid = 'pg_extension'::regclass "
19950 "AND deptype = 'e' "
19951 "ORDER BY 3");
19952
19954
19955 ntups = PQntuples(res);
19956
19960
19961 /*
19962 * Since we ordered the SELECT by referenced ID, we can expect that
19963 * multiple entries for the same extension will appear together; this
19964 * saves on searches.
19965 */
19966 ext = NULL;
19967
19969 {
19970 CatalogId objId;
19972
19976
19980
19982 {
19983 /* shouldn't happen */
19985 continue;
19986 }
19987
19988 recordExtensionMembership(objId, ext);
19989 }
19990
19991 PQclear(res);
19992
19993 destroyPQExpBuffer(query);
19994}
19995
19996/*
19997 * processExtensionTables --- deal with extension configuration tables
19998 *
19999 * There are two parts to this process:
20000 *
20001 * 1. Identify and create dump records for extension configuration tables.
20002 *
20003 * Extensions can mark tables as "configuration", which means that the user
20004 * is able and expected to modify those tables after the extension has been
20005 * loaded. For these tables, we dump out only the data- the structure is
20006 * expected to be handled at CREATE EXTENSION time, including any indexes or
20007 * foreign keys, which brings us to-
20008 *
20009 * 2. Record FK dependencies between configuration tables.
20010 *
20011 * Due to the FKs being created at CREATE EXTENSION time and therefore before
20012 * the data is loaded, we have to work out what the best order for reloading
20013 * the data is, to avoid FK violations when the tables are restored. This is
20014 * not perfect- we can't handle circular dependencies and if any exist they
20015 * will cause an invalid dump to be produced (though at least all of the data
20016 * is included for a user to manually restore). This is currently documented
20017 * but perhaps we can provide a better solution in the future.
20018 */
20019void
20022{
20024 PQExpBuffer query;
20025 PGresult *res;
20026 int ntups,
20027 i;
20029 i_confrelid;
20030
20031 /* Nothing to do if no extensions */
20033 return;
20034
20035 /*
20036 * Identify extension configuration tables and create TableDataInfo
20037 * objects for them, ensuring their data will be dumped even though the
20038 * tables themselves won't be.
20039 *
20040 * Note that we create TableDataInfo objects even in schema-only mode, ie,
20041 * user data in a configuration table is treated like schema data. This
20042 * seems appropriate since system data in a config table would get
20043 * reloaded by CREATE EXTENSION. If the extension is not listed in the
20044 * list of extensions to be included, none of its data is dumped.
20045 */
20047 {
20055
20056 /*
20057 * Check if this extension is listed as to include in the dump. If
20058 * not, any table data associated with it is discarded.
20059 */
20062 curext->dobj.catId.oid))
20063 continue;
20064
20065 /*
20066 * Check if this extension is listed as to exclude in the dump. If
20067 * yes, any table data associated with it is discarded.
20068 */
20071 curext->dobj.catId.oid))
20072 continue;
20073
20075 {
20077
20084
20086 {
20091
20094 continue;
20095
20096 /*
20097 * Tables of not-to-be-dumped extensions shouldn't be dumped
20098 * unless the table or its schema is explicitly included
20099 */
20101 {
20102 /* check table explicitly requested */
20105 configtbloid))
20107
20108 /* check table's schema explicitly requested */
20110 DUMP_COMPONENT_DATA)
20112 }
20113
20114 /* check table excluded by an exclusion switch */
20117 configtbloid))
20119
20120 /* check schema excluded by an exclusion switch */
20122 configtbl->dobj.namespace->dobj.catId.oid))
20124
20126 {
20129 {
20132 }
20133 }
20134 }
20135 }
20140 }
20141
20142 /*
20143 * Now that all the TableDataInfo objects have been created for all the
20144 * extensions, check their FK dependencies and register them to try and
20145 * dump the data out in an order that they can be restored in.
20146 *
20147 * Note that this is not a problem for user tables as their FKs are
20148 * recreated after the data has been loaded.
20149 */
20150
20151 query = createPQExpBuffer();
20152
20153 printfPQExpBuffer(query,
20154 "SELECT conrelid, confrelid "
20155 "FROM pg_constraint "
20156 "JOIN pg_depend ON (objid = confrelid) "
20157 "WHERE contype = 'f' "
20158 "AND refclassid = 'pg_extension'::regclass "
20159 "AND classid = 'pg_class'::regclass;");
20160
20162 ntups = PQntuples(res);
20163
20166
20167 /* Now get the dependencies and register them */
20169 {
20170 Oid conrelid,
20171 confrelid;
20173 *contable;
20174
20177 contable = findTableByOid(conrelid);
20179
20182 contable == NULL ||
20184 continue;
20185
20186 /*
20187 * Make referencing TABLE_DATA object depend on the referenced table's
20188 * TABLE_DATA object.
20189 */
20192 }
20193 PQclear(res);
20194 destroyPQExpBuffer(query);
20195}
20196
20197/*
20198 * getDependencies --- obtain available dependency data
20199 */
20200static void
20202{
20203 PQExpBuffer query;
20204 PGresult *res;
20205 int ntups,
20206 i;
20208 i_objid,
20209 i_refclassid,
20210 i_refobjid,
20211 i_deptype;
20212 DumpableObject *dobj,
20213 *refdobj;
20214
20216
20217 query = createPQExpBuffer();
20218
20219 /*
20220 * Messy query to collect the dependency data we need. Note that we
20221 * ignore the sub-object column, so that dependencies of or on a column
20222 * look the same as dependencies of or on a whole table.
20223 *
20224 * PIN dependencies aren't interesting, and EXTENSION dependencies were
20225 * already processed by getExtensionMembership.
20226 */
20228 "classid, objid, refclassid, refobjid, deptype "
20229 "FROM pg_depend "
20230 "WHERE deptype != 'p' AND deptype != 'e'\n");
20231
20232 /*
20233 * Since we don't treat pg_amop entries as separate DumpableObjects, we
20234 * have to translate their dependencies into dependencies of their parent
20235 * opfamily. Ignore internal dependencies though, as those will point to
20236 * their parent opclass, which we needn't consider here (and if we did,
20237 * it'd just result in circular dependencies). Also, "loose" opfamily
20238 * entries will have dependencies on their parent opfamily, which we
20239 * should drop since they'd likewise become useless self-dependencies.
20240 * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
20241 */
20243 "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
20244 "FROM pg_depend d, pg_amop o "
20245 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20246 "classid = 'pg_amop'::regclass AND objid = o.oid "
20247 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n");
20248
20249 /* Likewise for pg_amproc entries */
20251 "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
20252 "FROM pg_depend d, pg_amproc p "
20253 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20254 "classid = 'pg_amproc'::regclass AND objid = p.oid "
20255 "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n");
20256
20257 /*
20258 * Translate dependencies of pg_propgraph_element entries into
20259 * dependencies of their parent pg_class entry.
20260 */
20263 "SELECT 'pg_class'::regclass AS classid, pgepgid AS objid, refclassid, refobjid, deptype "
20264 "FROM pg_depend d, pg_propgraph_element pge "
20265 "WHERE deptype NOT IN ('p', 'e', 'i') AND "
20266 "classid = 'pg_propgraph_element'::regclass AND objid = pge.oid\n");
20267
20268 /* Sort the output for efficiency below */
20270
20272
20273 ntups = PQntuples(res);
20274
20280
20281 /*
20282 * Since we ordered the SELECT by referencing ID, we can expect that
20283 * multiple entries for the same object will appear together; this saves
20284 * on searches.
20285 */
20286 dobj = NULL;
20287
20289 {
20290 CatalogId objId;
20292 char deptype;
20293
20299
20303 dobj = findObjectByCatalogId(objId);
20304
20305 /*
20306 * Failure to find objects mentioned in pg_depend is not unexpected,
20307 * since for example we don't collect info about TOAST tables.
20308 */
20310 {
20311#ifdef NOT_USED
20314#endif
20315 continue;
20316 }
20317
20319
20321 {
20322#ifdef NOT_USED
20325#endif
20326 continue;
20327 }
20328
20329 /*
20330 * For 'x' dependencies, mark the object for later; we still add the
20331 * normal dependency, for possible ordering purposes. Currently
20332 * pg_dump_sort.c knows to put extensions ahead of all object types
20333 * that could possibly depend on them, but this is safer.
20334 */
20335 if (deptype == 'x')
20337
20338 /*
20339 * Ordinarily, table rowtypes have implicit dependencies on their
20340 * tables. However, for a composite type the implicit dependency goes
20341 * the other way in pg_depend; which is the right thing for DROP but
20342 * it doesn't produce the dependency ordering we need. So in that one
20343 * case, we reverse the direction of the dependency.
20344 */
20345 if (deptype == 'i' &&
20349 else
20350 /* normal case */
20352 }
20353
20354 PQclear(res);
20355
20356 destroyPQExpBuffer(query);
20357}
20358
20359
20360/*
20361 * createBoundaryObjects - create dummy DumpableObjects to represent
20362 * dump section boundaries.
20363 */
20366{
20368
20370
20375
20380
20382}
20383
20384/*
20385 * addBoundaryDependencies - add dependencies as needed to enforce the dump
20386 * section boundaries.
20387 */
20388static void
20391{
20395
20397 {
20399
20400 /*
20401 * The classification of object types here must match the SECTION_xxx
20402 * values assigned during subsequent ArchiveEntry calls!
20403 */
20405 {
20431 /* Pre-data objects: must come before the pre-data boundary */
20433 break;
20438 /* Data objects: must come between the boundaries */
20441 break;
20455 /* Post-data objects: must come after the post-data boundary */
20457 break;
20459 /* Rules are post-data, but only if dumped separately */
20462 break;
20465 /* Constraints are post-data, but only if dumped separately */
20468 break;
20470 /* nothing to do */
20471 break;
20473 /* must come after the pre-data boundary */
20475 break;
20477 /* stats section varies by parent object type, DATA or POST */
20479 {
20482 }
20483 else
20485 break;
20486 }
20487 }
20488}
20489
20490
20491/*
20492 * BuildArchiveDependencies - create dependency data for archive TOC entries
20493 *
20494 * The raw dependency data obtained by getDependencies() is not terribly
20495 * useful in an archive dump, because in many cases there are dependency
20496 * chains linking through objects that don't appear explicitly in the dump.
20497 * For example, a view will depend on its _RETURN rule while the _RETURN rule
20498 * will depend on other objects --- but the rule will not appear as a separate
20499 * object in the dump. We need to adjust the view's dependencies to include
20500 * whatever the rule depends on that is included in the dump.
20501 *
20502 * Just to make things more complicated, there are also "special" dependencies
20503 * such as the dependency of a TABLE DATA item on its TABLE, which we must
20504 * not rearrange because pg_restore knows that TABLE DATA only depends on
20505 * its table. In these cases we must leave the dependencies strictly as-is
20506 * even if they refer to not-to-be-dumped objects.
20507 *
20508 * To handle this, the convention is that "special" dependencies are created
20509 * during ArchiveEntry calls, and an archive TOC item that has any such
20510 * entries will not be touched here. Otherwise, we recursively search the
20511 * DumpableObject data structures to build the correct dependencies for each
20512 * archive TOC item.
20513 */
20514static void
20516{
20518 TocEntry *te;
20519
20520 /* Scan all TOC entries in the archive */
20522 {
20523 DumpableObject *dobj;
20524 DumpId *dependencies;
20525 int nDeps;
20526 int allocDeps;
20527
20528 /* No need to process entries that will not be dumped */
20530 continue;
20531 /* Ignore entries that already have "special" dependencies */
20533 continue;
20534 /* Otherwise, look up the item's original DumpableObject, if any */
20537 continue;
20538 /* No work if it has no dependencies */
20540 continue;
20541 /* Set up work array */
20542 allocDeps = 64;
20544 nDeps = 0;
20545 /* Recursively find all dumpable dependencies */
20546 findDumpableDependencies(AH, dobj,
20547 &dependencies, &nDeps, &allocDeps);
20548 /* And save 'em ... */
20549 if (nDeps > 0)
20550 {
20552 te->dependencies = dependencies;
20553 te->nDeps = nDeps;
20554 }
20555 else
20556 pg_free(dependencies);
20557 }
20558}
20559
20560/* Recursive search subroutine for BuildArchiveDependencies */
20561static void
20564{
20566
20567 /*
20568 * Ignore section boundary objects: if we search through them, we'll
20569 * report lots of bogus dependencies.
20570 */
20573 return;
20574
20576 {
20578
20580 {
20581 /* Object will be dumped, so just reference it as a dependency */
20582 if (*nDeps >= *allocDeps)
20583 {
20584 *allocDeps *= 2;
20586 }
20587 (*dependencies)[*nDeps] = depid;
20588 (*nDeps)++;
20589 }
20590 else
20591 {
20592 /*
20593 * Object will not be dumped, so recursively consider its deps. We
20594 * rely on the assumption that sortDumpableObjects already broke
20595 * any dependency loops, else we might recurse infinitely.
20596 */
20598
20601 dependencies, nDeps, allocDeps);
20602 }
20603 }
20604}
20605
20606
20607/*
20608 * getFormattedTypeName - retrieve a nicely-formatted type name for the
20609 * given type OID.
20610 *
20611 * This does not guarantee to schema-qualify the output, so it should not
20612 * be used to create the target object name for CREATE or ALTER commands.
20613 *
20614 * Note that the result is cached and must not be freed by the caller.
20615 */
20616static const char *
20618{
20621 PQExpBuffer query;
20622 PGresult *res;
20623
20624 if (oid == 0)
20625 {
20627 return "*";
20629 return "NONE";
20630 }
20631
20632 /* see if we have the result cached in the type's TypeInfo record */
20636
20637 query = createPQExpBuffer();
20639 oid);
20640
20642
20643 /* result of format_type is already quoted */
20645
20646 PQclear(res);
20647 destroyPQExpBuffer(query);
20648
20649 /*
20650 * Cache the result for re-use in later requests, if possible. If we
20651 * don't have a TypeInfo for the type, the string will be leaked once the
20652 * caller is done with it ... but that case really should not happen, so
20653 * leaking if it does seems acceptable.
20654 */
20657
20659}
20660
20661/*
20662 * Return a column list clause for the given relation.
20663 *
20664 * Special case: if there are no undropped columns in the relation, return
20665 * "", not an invalid "()" column list.
20666 */
20667static const char *
20669{
20676
20680 {
20682 continue;
20684 continue;
20689 }
20690
20692 return ""; /* no undropped columns */
20693
20696}
20697
20698/*
20699 * Check if a reloptions array is nonempty.
20700 */
20701static bool
20703{
20704 /* Don't want to print it if it's just "{}" */
20706}
20707
20708/*
20709 * Format a reloptions array and append it to the given buffer.
20710 *
20711 * "prefix" is prepended to the option names; typically it's "" or "toast.".
20712 */
20713static void
20716{
20717 bool res;
20718
20720 fout->std_strings);
20721 if (!res)
20723}
20724
20725/*
20726 * read_dump_filters - retrieve object identifier patterns from file
20727 *
20728 * Parse the specified filter file for include and exclude patterns, and add
20729 * them to the relevant lists. If the filename is "-" then filters will be
20730 * read from STDIN rather than a file.
20731 */
20732static void
20734{
20736 char *objname;
20738 FilterObjectType objtype;
20739
20741
20743 {
20745 {
20746 switch (objtype)
20747 {
20749 break;
20757 "include",
20758 filter_object_type_name(objtype));
20759 exit_nicely(1);
20760 break; /* unreachable */
20761
20764 break;
20767 break;
20771 break;
20775 break;
20778 objname);
20780 break;
20781 }
20782 }
20784 {
20785 switch (objtype)
20786 {
20788 break;
20795 "exclude",
20796 filter_object_type_name(objtype));
20797 exit_nicely(1);
20798 break;
20799
20802 break;
20805 objname);
20806 break;
20809 objname);
20810 break;
20813 break;
20816 break;
20819 objname);
20820 break;
20821 }
20822 }
20823 else
20824 {
20827 }
20828
20829 if (objname)
20830 free(objname);
20831 }
20832
20834}
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:7714
int PQsetClientEncoding(PGconn *conn, const char *encoding)
Definition fe-connect.c:7857
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 @175 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 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:1221
TocEntry * ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
Definition pg_backup_archiver.c:1242
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:221
PGresult * ExecuteSqlQuery(Archive *AHX, const char *query, ExecStatusType status)
Definition pg_backup_db.c:233
PGresult * ExecuteSqlQueryForSingleRow(Archive *fout, const char *query)
Definition pg_backup_db.c:248
void set_dump_section(const char *arg, int *dumpSections)
Definition pg_backup_utils.c:80
static void expand_schema_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
Definition pg_dump.c:1638
void getConstraints(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8250
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:16364
static void dumpAttrDef(Archive *fout, const AttrDefInfo *adinfo)
Definition pg_dump.c:18172
ExtensionInfo * getExtensions(Archive *fout, int *numExtensions)
Definition pg_dump.c:6169
static void selectDumpableProcLang(ProcLangInfo *plang, Archive *fout)
Definition pg_dump.c:2181
static void collectBinaryUpgradeClassOids(Archive *fout)
Definition pg_dump.c:5869
static PQExpBuffer createDummyViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17007
static void dumpUserMappings(Archive *fout, const char *servername, const char *namespace, const char *owner, CatalogId catalogId, DumpId dumpId)
Definition pg_dump.c:16178
static void dumpPublicationNamespace(Archive *fout, const PublicationSchemaInfo *pubsinfo)
Definition pg_dump.c:4969
static void addBoundaryDependencies(DumpableObject **dobjs, int numObjs, DumpableObject *boundaryObjs)
Definition pg_dump.c:20390
static void selectDumpableTable(TableInfo *tbinfo, Archive *fout)
Definition pg_dump.c:2050
static char * convertTSFunction(Archive *fout, Oid funcOid)
Definition pg_dump.c:14373
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:5682
static Oid get_next_possible_free_pg_type_oid(Archive *fout, PQExpBuffer upgrade_query)
Definition pg_dump.c:5727
static void dumpNamespace(Archive *fout, const NamespaceInfo *nspinfo)
Definition pg_dump.c:11843
static bool forcePartitionRootLoad(const TableInfo *tbinfo)
Definition pg_dump.c:2803
static void dumpBaseType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12436
static char * dumpRelationStats_dumper(Archive *fout, const void *userArg, const TocEntry *te)
Definition pg_dump.c:11084
static void dumpTSDictionary(Archive *fout, const TSDictInfo *dictinfo)
Definition pg_dump.c:15747
static void dumpRelationStats(Archive *fout, const RelStatsInfo *rsinfo)
Definition pg_dump.c:11360
static void dumpTableComment(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:11386
static SimpleStringList extension_include_patterns
Definition pg_dump.c:185
static void selectDumpableNamespace(NamespaceInfo *nsinfo, Archive *fout)
Definition pg_dump.c:1965
static void dumpTrigger(Archive *fout, const TriggerInfo *tginfo)
Definition pg_dump.c:19545
static void binary_upgrade_set_type_oids_by_rel(Archive *fout, PQExpBuffer upgrade_buffer, const TableInfo *tbinfo)
Definition pg_dump.c:5838
static PQExpBuffer createViewAsClause(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:16958
static void dumpStatisticsExt(Archive *fout, const StatsExtInfo *statsextinfo)
Definition pg_dump.c:18456
void getPolicies(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4187
static void dumpRangeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12214
void getExtensionMembership(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:19928
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:10945
static char * getFormattedOperatorName(const char *oproid)
Definition pg_dump.c:14343
static char * format_function_signature(Archive *fout, const FuncInfo *finfo, bool honor_quotes)
Definition pg_dump.c:13406
static void dumpConstraint(Archive *fout, const ConstraintInfo *coninfo)
Definition pg_dump.c:18813
static void dumpTableAttach(Archive *fout, const TableAttachInfo *attachinfo)
Definition pg_dump.c:18104
static void dumpAccessMethod(Archive *fout, const AccessMethodInfo *aminfo)
Definition pg_dump.c:14395
static void selectDumpableStatisticsObject(StatsExtInfo *sobj, Archive *fout)
Definition pg_dump.c:2298
static void selectDumpablePublicationObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2280
static void dumpSequenceData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:19456
static void selectDumpableDefaultACL(DefaultACLInfo *dinfo, DumpOptions *dopt)
Definition pg_dump.c:2134
static void BuildArchiveDependencies(Archive *fout)
Definition pg_dump.c:20516
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:7073
void getOwnedSeqs(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7626
static void makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo)
Definition pg_dump.c:3000
static const char * getAttrName(int attrnum, const TableInfo *tblInfo)
Definition pg_dump.c:18233
static void dumpForeignServer(Archive *fout, const ForeignServerInfo *srvinfo)
Definition pg_dump.c:16078
static void appendReloptionsArrayAH(PQExpBuffer buffer, const char *reloptions, const char *prefix, Archive *fout)
Definition pg_dump.c:20715
static void dumpTableData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2831
static void prohibit_crossdb_refs(PGconn *conn, const char *dbname, const char *pattern)
Definition pg_dump.c:1898
static int dumpTableData_copy(Archive *fout, const void *dcontext)
Definition pg_dump.c:2338
static const char * getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts)
Definition pg_dump.c:20618
static void buildMatViewRefreshDependencies(Archive *fout)
Definition pg_dump.c:3090
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:5758
void getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:4838
static void dumpShellType(Archive *fout, const ShellTypeInfo *stinfo)
Definition pg_dump.c:13205
static void refreshMatViewData(Archive *fout, const TableDataInfo *tdinfo)
Definition pg_dump.c:2946
static int findComments(Oid classoid, Oid objoid, CommentItem **items)
Definition pg_dump.c:11484
static SimpleStringList foreign_servers_include_patterns
Definition pg_dump.c:182
static void selectDumpableCast(CastInfo *cast, Archive *fout)
Definition pg_dump.c:2156
static void dumpPublication(Archive *fout, const PublicationInfo *pubinfo)
Definition pg_dump.c:4636
void getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:7807
static void addConstrChildIdxDeps(DumpableObject *dobj, const IndxInfo *refidx)
Definition pg_dump.c:8409
static int findSecLabels(Oid classoid, Oid objoid, SecLabelItem **items)
Definition pg_dump.c:16654
static SimpleStringList table_include_patterns_and_children
Definition pg_dump.c:173
static char * convertRegProcReference(const char *proc)
Definition pg_dump.c:14302
static void getTableData(DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind)
Definition pg_dump.c:2981
void getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables)
Definition pg_dump.c:9185
static void getDomainConstraints(Archive *fout, TypeInfo *tyinfo)
Definition pg_dump.c:8432
static void dumpOpfamily(Archive *fout, const OpfamilyInfo *opfinfo)
Definition pg_dump.c:14744
static void dumpDefaultACL(Archive *fout, const DefaultACLInfo *daclinfo)
Definition pg_dump.c:16272
static void selectDumpableObject(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:2316
static void dumpTSTemplate(Archive *fout, const TSTemplateInfo *tmplinfo)
Definition pg_dump.c:15827
static void dumpIndexAttach(Archive *fout, const IndexAttachInfo *attachinfo)
Definition pg_dump.c:18413
static void dumpSubscriptionTable(Archive *fout, const SubRelInfo *subrinfo)
Definition pg_dump.c:5448
static char * format_function_arguments(const FuncInfo *finfo, const char *funcargs, bool is_agg)
Definition pg_dump.c:13383
static void dumpTransform(Archive *fout, const TransformInfo *transform)
Definition pg_dump.c:13954
static void dumpPublicationTable(Archive *fout, const PublicationRelInfo *pubrinfo)
Definition pg_dump.c:5012
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:5993
static void dumpDumpableObject(Archive *fout, DumpableObject *dobj)
Definition pg_dump.c:11646
static void dumpDatabaseConfig(Archive *AH, PQExpBuffer outbuf, const char *dbname, Oid dboid)
Definition pg_dump.c:3742
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:19134
static void dumpUndefinedType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12372
static void selectDumpableAccessMethod(AccessMethodInfo *method, Archive *fout)
Definition pg_dump.c:2213
static const char * fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer)
Definition pg_dump.c:20669
static void expand_table_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names, bool with_child_tables)
Definition pg_dump.c:1802
static void findDumpableDependencies(ArchiveHandle *AH, const DumpableObject *dobj, DumpId **dependencies, int *nDeps, int *allocDeps)
Definition pg_dump.c:20563
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:9969
static void dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:17047
static void dumpTSParser(Archive *fout, const TSParserInfo *prsinfo)
Definition pg_dump.c:15683
static void expand_foreign_server_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
Definition pg_dump.c:1750
static void dumpCompositeType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12910
static void dumpEnumType(Archive *fout, const TypeInfo *tyinfo)
Definition pg_dump.c:12074
static void dumpExtension(Archive *fout, const ExtensionInfo *extinfo)
Definition pg_dump.c:11920
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:18533
static char * get_synchronized_snapshot(Archive *fout)
Definition pg_dump.c:1586
static void dumpSubscription(Archive *fout, const SubscriptionInfo *subinfo)
Definition pg_dump.c:5517
static void appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname, const char *argtype, const char *argval)
Definition pg_dump.c:10961
void processExtensionTables(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition pg_dump.c:20021
static void dumpEventTrigger(Archive *fout, const EventTriggerInfo *evtinfo)
Definition pg_dump.c:19671
static int BinaryUpgradeClassOidItemCmp(const void *p1, const void *p2)
Definition pg_dump.c:5853
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:10845
static SimpleStringList tabledata_exclude_patterns
Definition pg_dump.c:178
static void dumpConversion(Archive *fout, const ConvInfo *convinfo)
Definition pg_dump.c:15215
static void dumpForeignDataWrapper(Archive *fout, const FdwInfo *fdwinfo)
Definition pg_dump.c:16005
static void dumpProcLang(Archive *fout, const ProcLangInfo *plang)
Definition pg_dump.c:13251
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:16492
static void selectDumpableExtension(ExtensionInfo *extinfo, DumpOptions *dopt)
Definition pg_dump.c:2241
void getTriggers(Archive *fout, TableInfo tblinfo[], int numTables)
Definition pg_dump.c:8641
static ArchiveFormat parseArchiveFormat(const char *format, ArchiveMode *mode)
Definition pg_dump.c:1600
static void read_dump_filters(const char *filename, DumpOptions *dopt)
Definition pg_dump.c:20734
static void dumpTSConfig(Archive *fout, const TSConfigInfo *cfginfo)
Definition pg_dump.c:15885
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:9084
static bool checkExtensionMembership(DumpableObject *dobj, Archive *fout)
Definition pg_dump.c:1923
static int dumpTableData_insert(Archive *fout, const void *dcontext)
Definition pg_dump.c:2509
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:5903
static void set_restrict_relation_kind(Archive *AH, const char *value)
Definition pg_dump.c:5092
static char * format_aggregate_signature(const AggInfo *agginfo, Archive *fout, bool honor_quotes)
Definition pg_dump.c:15311
static void dumpSequence(Archive *fout, const TableInfo *tbinfo)
Definition pg_dump.c:19244
bool shouldPrintColumn(const DumpOptions *dopt, const TableInfo *tbinfo, int colno)
Definition pg_dump.c:10096
static TableInfo * getRootTableInfo(const TableInfo *tbinfo)
Definition pg_dump.c:2778
static SimpleOidList foreign_servers_include_oids
Definition pg_dump.c:183
static void dumpCollation(Archive *fout, const CollInfo *collinfo)
Definition pg_dump.c:14963
static void dumpTableSecLabel(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
Definition pg_dump.c:16572
static void dumpCompositeTypeColComments(Archive *fout, const TypeInfo *tyinfo, PGresult *res)
Definition pg_dump.c:13116
static void expand_extension_name_patterns(Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
Definition pg_dump.c:1697
static void selectDumpableType(TypeInfo *tyinfo, Archive *fout)
Definition pg_dump.c:2089
static void dumpOpclass(Archive *fout, const OpclassInfo *opcinfo)
Definition pg_dump.c:14463
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:1051
bool parsePGArray(const char *atext, char ***itemarray, int *nitems)
Definition string_utils.c:817
bool appendReloptionsArray(PQExpBuffer buffer, const char *reloptions, const char *prefix, int encoding, bool std_strings)
Definition string_utils.c:964
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 20390 of file pg_dump.c.
20392{
20396
20398 {
20400
20401 /*
20402 * The classification of object types here must match the SECTION_xxx
20403 * values assigned during subsequent ArchiveEntry calls!
20404 */
20406 {
20432 /* Pre-data objects: must come before the pre-data boundary */
20434 break;
20439 /* Data objects: must come between the boundaries */
20442 break;
20456 /* Post-data objects: must come after the post-data boundary */
20458 break;
20460 /* Rules are post-data, but only if dumped separately */
20463 break;
20466 /* Constraints are post-data, but only if dumped separately */
20469 break;
20471 /* nothing to do */
20472 break;
20474 /* must come after the pre-data boundary */
20476 break;
20478 /* stats section varies by parent object type, DATA or POST */
20480 {
20483 }
20484 else
20486 break;
20487 }
20488 }
20489}
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 8409 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 5682 of file pg_dump.c.
5688{
5690 {
5692 PGresult *res;
5693 PQExpBuffer query;
5694 int ntups;
5697
5698 /* dodge fmtId() non-reentrancy */
5700
5701 query = createPQExpBuffer();
5702 appendPQExpBuffer(query,
5703 "SELECT e.extname "
5704 "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
5705 "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
5706 "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
5707 "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
5708 catalog,
5711 ntups = PQntuples(res);
5714 {
5716 keyword, nm,
5718 }
5719
5720 PQclear(res);
5721 destroyPQExpBuffer(query);
5723 }
5724}
References appendPQExpBuffer(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::depends_on_ext, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), fmtId(), i, CatalogId::oid, pg_free(), pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, and PQntuples.
Referenced by dumpConstraint(), dumpFunc(), dumpIndex(), dumpTableSchema(), and dumpTrigger().
◆ appendNamedArgument()
|
static |
Definition at line 10961 of file pg_dump.c.
10963{
10965
10968
10971}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, and fb().
Referenced by dumpRelationStats_dumper(), and dumpStatisticsExtStats().
◆ appendReloptionsArrayAH()
|
static |
Definition at line 20715 of file pg_dump.c.
References appendReloptionsArray(), fb(), and pg_log_warning.
Referenced by dumpConstraint(), dumpRule(), and dumpTableSchema().
◆ binary_upgrade_extension_member()
|
static |
Definition at line 5993 of file pg_dump.c.
5998{
6001
6003 return;
6004
6005 /*
6006 * Find the parent extension. We could avoid this search if we wanted to
6007 * add a link field to DumpableObject, but the space costs of that would
6008 * be considerable. We assume that member objects could only have a
6009 * direct dependency on their own extension, not any others.
6010 */
6012 {
6015 break;
6017 }
6020 objtype, objname);
6021
6023 "\n-- For binary upgrade, handle extension membership the hard way\n");
6026 objtype);
6030}
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 5903 of file pg_dump.c.
5905{
5907 BinaryUpgradeClassOidItem *entry;
5908
5910
5911 /*
5912 * Preserve the OID and relfilenumber of the table, table's index, table's
5913 * toast table and toast table's index if any.
5914 *
5915 * One complexity is that the current table definition might not require
5916 * the creation of a TOAST table, but the old database might have a TOAST
5917 * table that was created earlier, before some wide columns were dropped.
5918 * By setting the TOAST oid we force creation of the TOAST heap and index
5919 * by the new backend, so we can copy the files during binary upgrade
5920 * without worrying about this case.
5921 */
5925 BinaryUpgradeClassOidItemCmp);
5926
5928 "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
5929
5932 {
5934 "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
5935 pg_class_oid);
5936
5937 /*
5938 * Not every relation has storage. Also, in a pre-v12 database,
5939 * partitioned tables have a relfilenumber, which should not be
5940 * preserved when upgrading.
5941 */
5945 "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
5946 entry->relfilenumber);
5947
5948 /*
5949 * In a pre-v12 database, partitioned tables might be marked as having
5950 * toast tables, but we should ignore them if so.
5951 */
5954 {
5956 "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
5957 entry->toast_oid);
5959 "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
5960 entry->toast_relfilenumber);
5961
5962 /* every toast table has an index */
5964 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5965 entry->toast_index_oid);
5967 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5968 entry->toast_index_relfilenumber);
5969 }
5970 }
5971 else
5972 {
5973 /* Preserve the OID and relfilenumber of the index */
5975 "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
5976 pg_class_oid);
5978 "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
5979 entry->relfilenumber);
5980 }
5981
5983}
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 5838 of file pg_dump.c.
5841{
5843
5847}
References binary_upgrade_set_type_oids_by_type_oid(), fb(), and OidIsValid.
Referenced by dumpTableSchema().
◆ binary_upgrade_set_type_oids_by_type_oid()
|
static |
Definition at line 5758 of file pg_dump.c.
5763{
5765 PGresult *res;
5770
5773 "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5774 pg_type_oid);
5775
5779 else
5781
5784
5786 {
5788 "\n-- For binary upgrade, must preserve pg_type array oid\n");
5790 "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5791 pg_type_array_oid);
5792 }
5793
5794 /*
5795 * Pre-set the multirange type oid and its own array type oid.
5796 */
5798 {
5800 {
5802 "SELECT t.oid, t.typarray "
5803 "FROM pg_catalog.pg_type t "
5804 "JOIN pg_catalog.pg_range r "
5805 "ON t.oid = r.rngmultitypid "
5806 "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
5807 pg_type_oid);
5808
5810
5813
5814 PQclear(res);
5815 }
5816 else
5817 {
5820 }
5821
5823 "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
5825 "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5826 pg_type_multirange_oid);
5828 "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
5830 "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
5831 pg_type_multirange_array_oid);
5832 }
5833
5835}
References appendPQExpBuffer(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fb(), findTypeByOid(), get_next_possible_free_pg_type_oid(), InvalidOid, OidIsValid, PQclear, PQfnumber(), PQgetvalue, printfPQExpBuffer(), and tinfo.
Referenced by binary_upgrade_set_type_oids_by_rel(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), dumpShellType(), and dumpUndefinedType().
◆ BinaryUpgradeClassOidItemCmp()
Definition at line 5853 of file pg_dump.c.
5854{
5857
5859}
References fb(), BinaryUpgradeClassOidItem::oid, and pg_cmp_u32().
Referenced by binary_upgrade_set_pg_class_oids().
◆ BuildArchiveDependencies()
Definition at line 20516 of file pg_dump.c.
20517{
20519 TocEntry *te;
20520
20521 /* Scan all TOC entries in the archive */
20523 {
20524 DumpableObject *dobj;
20525 DumpId *dependencies;
20526 int nDeps;
20527 int allocDeps;
20528
20529 /* No need to process entries that will not be dumped */
20531 continue;
20532 /* Ignore entries that already have "special" dependencies */
20534 continue;
20535 /* Otherwise, look up the item's original DumpableObject, if any */
20538 continue;
20539 /* No work if it has no dependencies */
20541 continue;
20542 /* Set up work array */
20543 allocDeps = 64;
20545 nDeps = 0;
20546 /* Recursively find all dumpable dependencies */
20547 findDumpableDependencies(AH, dobj,
20548 &dependencies, &nDeps, &allocDeps);
20549 /* And save 'em ... */
20550 if (nDeps > 0)
20551 {
20553 te->dependencies = dependencies;
20554 te->nDeps = nDeps;
20555 }
20556 else
20557 pg_free(dependencies);
20558 }
20559}
References _tocEntry::dependencies, _tocEntry::dumpId, fb(), findDumpableDependencies(), findObjectByDumpId(), _tocEntry::nDeps, _dumpableObject::nDeps, _tocEntry::next, pg_free(), pg_malloc_array, pg_realloc_array, _tocEntry::reqs, and _archiveHandle::toc.
Referenced by main().
◆ buildMatViewRefreshDependencies()
Definition at line 3090 of file pg_dump.c.
3091{
3092 PQExpBuffer query;
3093 PGresult *res;
3094 int ntups,
3095 i;
3097 i_objid,
3098 i_refobjid;
3099
3100 query = createPQExpBuffer();
3101
3103 "( "
3104 "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
3105 "FROM pg_depend d1 "
3106 "JOIN pg_class c1 ON c1.oid = d1.objid "
3108 " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
3109 "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
3110 "AND d2.objid = r1.oid "
3111 "AND d2.refobjid <> d1.objid "
3112 "JOIN pg_class c2 ON c2.oid = d2.refobjid "
3115 "WHERE d1.classid = 'pg_class'::regclass "
3116 "UNION "
3117 "SELECT w.objid, d3.refobjid, c3.relkind "
3118 "FROM w "
3119 "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
3120 "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
3121 "AND d3.objid = r3.oid "
3122 "AND d3.refobjid <> w.refobjid "
3123 "JOIN pg_class c3 ON c3.oid = d3.refobjid "
3126 ") "
3127 "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
3128 "FROM w "
3130
3132
3133 ntups = PQntuples(res);
3134
3138
3140 {
3141 CatalogId objId;
3143 DumpableObject *dobj;
3147
3152
3153 dobj = findObjectByCatalogId(objId);
3155 continue;
3156
3162 continue;
3164
3167 continue;
3168
3174 continue;
3176
3178
3181 }
3182
3183 PQclear(res);
3184
3185 destroyPQExpBuffer(query);
3186}
References addObjectDependency(), appendPQExpBufferStr(), Assert, atooid, CppAsString2, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_REFRESH_MATVIEW, DO_TABLE, _dumpableObject::dumpId, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), i, _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ checkExtensionMembership()
|
static |
Definition at line 1923 of file pg_dump.c.
1924{
1926
1928 return false;
1929
1931
1932 /* Record dependency so that getDependencies needn't deal with that */
1934
1935 /*
1936 * Mark the member object to have any non-initial ACLs dumped. (Any
1937 * initial ACLs will be removed later, using data from pg_init_privs, so
1938 * that we'll dump only the delta from the extension's initial setup.)
1939 *
1940 * In binary upgrades, we still dump all components of the members
1941 * individually, since the idea is to exactly reproduce the database
1942 * contents rather than replace the extension contents with something
1943 * different.
1944 *
1945 * Note: it might be interesting someday to implement storage and delta
1946 * dumping of extension members' RLS policies and/or security labels.
1947 * However there is a pitfall for RLS policies: trying to dump them
1948 * requires getting a lock on their tables, and the calling user might not
1949 * have privileges for that. We need no lock to examine a table's ACLs,
1950 * so the current feature doesn't have a problem of that sort.
1951 */
1954 else
1956
1957 return true;
1958}
References addObjectDependency(), _dumpableObject::catId, _extensionInfo::dobj, _dumpableObject::dump, DUMP_COMPONENT_ACL, _dumpableObject::dump_contains, _dumpableObject::dumpId, _dumpableObject::ext_member, fb(), and findOwningExtension().
Referenced by selectDumpableAccessMethod(), selectDumpableCast(), selectDumpableNamespace(), selectDumpableObject(), selectDumpableProcLang(), selectDumpablePublicationObject(), selectDumpableStatisticsObject(), selectDumpableTable(), and selectDumpableType().
◆ collectBinaryUpgradeClassOids()
Definition at line 5869 of file pg_dump.c.
5870{
5871 PGresult *res;
5872 const char *query;
5873
5874 query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
5875 "ct.relfilenode, i.indexrelid, cti.relfilenode "
5876 "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
5877 "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
5878 "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
5879 "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
5880 "ORDER BY c.oid;";
5881
5883
5885 binaryUpgradeClassOids =
5887
5889 {
5897 }
5898
5899 PQclear(res);
5900}
References atooid, binaryUpgradeClassOids, ExecuteSqlQuery(), fb(), 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 11561 of file pg_dump.c.
11562{
11563 PGresult *res;
11564 PQExpBuffer query;
11569 int ntups;
11571 DumpableObject *dobj;
11572
11573 query = createPQExpBuffer();
11574
11576 "FROM pg_catalog.pg_description "
11577 "ORDER BY classoid, objoid, objsubid");
11578
11580
11581 /* Construct lookup table containing OIDs in numeric form */
11582
11587
11588 ntups = PQntuples(res);
11589
11591 ncomments = 0;
11592 dobj = NULL;
11593
11595 {
11596 CatalogId objId;
11597 int subid;
11598
11602
11603 /* We needn't remember comments that don't match any dumpable object */
11607 dobj = findObjectByCatalogId(objId);
11609 continue;
11610
11611 /*
11612 * Comments on columns of composite types are linked to the type's
11613 * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
11614 * in the type's own DumpableObject.
11615 */
11618 {
11620
11624 }
11625 else
11626 dobj->components |= DUMP_COMPONENT_COMMENT;
11627
11632 ncomments++;
11633 }
11634
11635 PQclear(res);
11636 destroyPQExpBuffer(query);
11637}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, CommentItem::classoid, comments, createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_COMMENT, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), i, ncomments, CommentItem::objoid, CommentItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc_array, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, and CatalogId::tableoid.
Referenced by main().
◆ collectRoleNames()
Definition at line 10684 of file pg_dump.c.
10685{
10686 PGresult *res;
10687 const char *query;
10689
10690 query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
10691
10693
10695
10697
10699 {
10702 }
10703
10704 PQclear(res);
10705}
References atooid, ExecuteSqlQuery(), fb(), 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 16733 of file pg_dump.c.
16734{
16735 PGresult *res;
16736 PQExpBuffer query;
16742 int ntups;
16744 DumpableObject *dobj;
16745
16746 query = createPQExpBuffer();
16747
16748 appendPQExpBufferStr(query,
16749 "SELECT label, provider, classoid, objoid, objsubid "
16750 "FROM pg_catalog.pg_seclabels "
16751 "ORDER BY classoid, objoid, objsubid");
16752
16754
16755 /* Construct lookup table containing OIDs in numeric form */
16761
16762 ntups = PQntuples(res);
16763
16765 nseclabels = 0;
16766 dobj = NULL;
16767
16769 {
16770 CatalogId objId;
16771 int subid;
16772
16776
16777 /* We needn't remember labels that don't match any dumpable object */
16781 dobj = findObjectByCatalogId(objId);
16783 continue;
16784
16785 /*
16786 * Labels on columns of composite types are linked to the type's
16787 * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
16788 * in the type's own DumpableObject.
16789 */
16792 {
16794
16798 }
16799 else
16800 dobj->components |= DUMP_COMPONENT_SECLABEL;
16801
16807 nseclabels++;
16808 }
16809
16810 PQclear(res);
16811 destroyPQExpBuffer(query);
16812}
References appendPQExpBufferStr(), atooid, _dumpableObject::catId, SecLabelItem::classoid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, DUMP_COMPONENT_SECLABEL, ExecuteSqlQuery(), fb(), findObjectByCatalogId(), findTypeByOid(), i, SecLabelItem::label, nseclabels, SecLabelItem::objoid, SecLabelItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc_array, pg_strdup(), PGRES_TUPLES_OK, PQclear, PQfnumber(), PQgetvalue, PQntuples, SecLabelItem::provider, seclabels, and CatalogId::tableoid.
Referenced by main().
◆ collectSequences()
Definition at line 19188 of file pg_dump.c.
19189{
19190 PGresult *res;
19191 const char *query;
19192
19193 /*
19194 * Since version 18, we can gather the sequence data in this query with
19195 * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
19196 */
19199 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19200 "seqstart, seqincrement, "
19201 "seqmax, seqmin, "
19202 "seqcache, seqcycle, "
19203 "NULL, 'f' "
19204 "FROM pg_catalog.pg_sequence "
19205 "ORDER BY seqrelid";
19206 else
19207 query = "SELECT seqrelid, format_type(seqtypid, NULL), "
19208 "seqstart, seqincrement, "
19209 "seqmax, seqmin, "
19210 "seqcache, seqcycle, "
19211 "last_value, is_called "
19212 "FROM pg_catalog.pg_sequence, "
19213 "pg_get_sequence_data(seqrelid) "
19214 "ORDER BY seqrelid;";
19215
19217
19220
19222 {
19234 }
19235
19236 PQclear(res);
19237}
References atooid, SequenceItem::cache, SequenceItem::cycled, ExecuteSqlQuery(), fb(), i, SequenceItem::incby, SequenceItem::is_called, SequenceItem::last_value, SequenceItem::maxv, SequenceItem::minv, nsequences, SequenceItem::null_seqtuple, SequenceItem::oid, parse_sequence_type(), pg_malloc_array, PGRES_TUPLES_OK, PQclear, PQgetisnull, PQgetvalue, PQntuples, SequenceItem::seqtype, sequences, and SequenceItem::startv.
Referenced by main().
◆ convertRegProcReference()
◆ convertTSFunction()
Definition at line 14373 of file pg_dump.c.
14374{
14376 char query[128];
14377 PGresult *res;
14378
14380 "SELECT '%u'::pg_catalog.regproc", funcOid);
14382
14384
14385 PQclear(res);
14386
14388}
References ExecuteSqlQueryForSingleRow(), fb(), pg_strdup(), PQclear, PQgetvalue, result, and snprintf.
Referenced by dumpTSParser(), and dumpTSTemplate().
◆ createBoundaryObjects()
|
static |
Definition at line 20366 of file pg_dump.c.
20367{
20369
20371
20376
20381
20383}
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 17007 of file pg_dump.c.
17008{
17011
17013
17015 {
17019
17021
17022 /*
17023 * Must add collation if not default for the type, because CREATE OR
17024 * REPLACE VIEW won't change it
17025 */
17027 {
17028 CollInfo *coll;
17029
17031 if (coll)
17033 fmtQualifiedDumpable(coll));
17034 }
17035
17037 }
17038
17040}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), fb(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, j, OidIsValid, and result.
Referenced by dumpRule(), and dumpTableSchema().
◆ createViewAsClause()
|
static |
Definition at line 16958 of file pg_dump.c.
16959{
16962 PGresult *res;
16964
16965 /* Fetch the view definition */
16966 appendPQExpBuffer(query,
16967 "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
16968 tbinfo->dobj.catId.oid);
16969
16971
16973 {
16976 tbinfo->dobj.name);
16977 else
16979 tbinfo->dobj.name);
16980 }
16981
16983
16986 tbinfo->dobj.name);
16987
16988 /* Strip off the trailing semicolon so that other things may follow. */
16991
16992 PQclear(res);
16993 destroyPQExpBuffer(query);
16994
16996}
References appendBinaryPQExpBuffer(), appendPQExpBuffer(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fb(), len, pg_fatal, PGRES_TUPLES_OK, PQclear, PQgetlength, PQgetvalue, PQntuples, and result.
Referenced by dumpRule(), and dumpTableSchema().
◆ determineNotNullFlags()
|
static |
Definition at line 9969 of file pg_dump.c.
9977{
9979
9980 /*
9981 * If this not-null constraint is not valid, list its OID in
9982 * invalidnotnulloids and do nothing further. It'll be processed
9983 * elsewhere later.
9984 *
9985 * Because invalid not-null constraints are rare, we don't want to malloc
9986 * invalidnotnulloids until we're sure we're going it need it, which
9987 * happens here.
9988 */
9990 {
9992
9994 {
9998 }
9999 else
10001
10002 /*
10003 * Track when a parent constraint is invalid for the cases where a
10004 * child constraint has been validated independenly.
10005 */
10007
10008 /* nothing else to do */
10010 return;
10011 }
10012
10013 /*
10014 * notnull_noinh is straight from the query result. notnull_islocal also,
10015 * though flagInhAttrs may change that one later.
10016 */
10020
10021 /*
10022 * Determine a constraint name to use. If the column is not marked not-
10023 * null, we set NULL which cues ... to do nothing. An empty string says
10024 * to print an unnamed NOT NULL, and anything else is a constraint name to
10025 * use.
10026 */
10028 {
10029 /*
10030 * < 18 doesn't have not-null names, so an unnamed constraint is
10031 * sufficient.
10032 */
10035 else
10037 }
10038 else
10039 {
10042 else
10043 {
10044 /*
10045 * In binary upgrade of inheritance child tables, must have a
10046 * constraint name that we can UPDATE later; same if there's a
10047 * comment on the constraint.
10048 */
10050 !tbinfo->ispartition &&
10053 {
10056 }
10057 else
10058 {
10060
10061 /* XXX should match ChooseConstraintName better */
10067 else
10068 {
10071 }
10073 }
10074 }
10075 }
10076}
References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _dumpOptions::binary_upgrade, createPQExpBuffer(), fb(), j, pfree(), PQgetisnull, PQgetvalue, psprintf(), and pstrdup().
Referenced by getTableAttrs().
◆ dumpAccessMethod()
|
static |
Definition at line 14395 of file pg_dump.c.
14396{
14398 PQExpBuffer q;
14401
14402 /* Do nothing if not dumping schema */
14404 return;
14405
14406 q = createPQExpBuffer();
14408
14410
14412
14414 {
14417 break;
14420 break;
14421 default:
14424 destroyPQExpBuffer(q);
14427 return;
14428 }
14429
14431
14433 qamname);
14434
14438
14442 .description = "ACCESS METHOD",
14443 .section = SECTION_PRE_DATA,
14444 .createStmt = q->data,
14445 .dropStmt = delq->data));
14446
14447 /* Dump Access Method Comments */
14452
14453 destroyPQExpBuffer(q);
14456}
References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpOptions::dumpSchema, fb(), fmtId(), pg_free(), pg_log_warning, pg_strdup(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpACL()
|
static |
Definition at line 16364 of file pg_dump.c.
16368{
16376 PQExpBuffer sql;
16377
16378 /* Do nothing if ACL dump is not enabled */
16381
16382 /* --data-only skips ACLs *except* large object ACLs */
16385
16386 sql = createPQExpBuffer();
16387
16388 /*
16389 * In binary upgrade mode, we don't run an extension's script but instead
16390 * dump out the objects independently and then recreate them. To preserve
16391 * any initial privileges which were set on extension objects, we need to
16392 * compute the set of GRANT and REVOKE commands necessary to get from the
16393 * default privileges of an object to its initial privileges as recorded
16394 * in pg_init_privs.
16395 *
16396 * At restore time, we apply these commands after having called
16397 * binary_upgrade_set_record_init_privs(true). That tells the backend to
16398 * copy the results into pg_init_privs. This is how we preserve the
16399 * contents of that catalog across binary upgrades.
16400 */
16402 initprivs && *initprivs != '\0')
16403 {
16406 initprivs, acldefault, owner,
16410 appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
16411 }
16412
16413 /*
16414 * Now figure the GRANT and REVOKE commands needed to get to the object's
16415 * actual current ACL, starting from the initprivs if given, else from the
16416 * object-type-specific default. Also, while buildACLCommands will assume
16417 * that a NULL/empty acls string means it needn't do anything, what that
16418 * actually represents is the object-type-specific default; so we need to
16419 * substitute the acldefault string to get the right results in that case.
16420 */
16421 if (initprivs && *initprivs != '\0')
16422 {
16423 baseacls = initprivs;
16426 }
16427 else
16429
16435
16437 {
16440 int nDeps = 0;
16441
16442 if (tag)
16446 else
16448
16452
16454
16457 .namespace = nspname,
16458 .owner = owner,
16459 .description = "ACL",
16460 .section = SECTION_NONE,
16461 .createStmt = sql->data,
16462 .deps = aclDeps,
16463 .nDeps = nDeps));
16464
16466 }
16467
16468 destroyPQExpBuffer(sql);
16469
16471}
References _dumpableAcl::acl, acldefault(), _dumpableAcl::acldefault, _dumpOptions::aclsSkip, appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, buildACLCommands(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dumpOptions::dumpSchema, fb(), _dumpableAcl::initprivs, InvalidDumpId, PQExpBufferData::len, name, nilCatalogId, pg_fatal, _dumpableAcl::privtype, SECTION_NONE, subname, and type.
Referenced by dumpAgg(), dumpBaseType(), dumpCompositeType(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpLO(), dumpNamespace(), dumpProcLang(), dumpRangeType(), dumpTable(), and dumpUndefinedType().
◆ dumpAgg()
Definition at line 15343 of file pg_dump.c.
15344{
15346 PQExpBuffer query;
15347 PQExpBuffer q;
15349 PQExpBuffer details;
15353 PGresult *res;
15368 const char *aggsortop;
15371 const char *aggtranstype;
15372 const char *aggtransspace;
15379
15380 /* Do nothing if not dumping schema */
15382 return;
15383
15384 query = createPQExpBuffer();
15385 q = createPQExpBuffer();
15387 details = createPQExpBuffer();
15388
15390 {
15391 /* Set up query for aggregate-specific details */
15392 appendPQExpBufferStr(query,
15393 "PREPARE dumpAgg(pg_catalog.oid) AS\n");
15394
15395 appendPQExpBufferStr(query,
15396 "SELECT "
15397 "aggtransfn,\n"
15398 "aggfinalfn,\n"
15399 "aggtranstype::pg_catalog.regtype,\n"
15400 "agginitval,\n"
15401 "aggsortop,\n"
15402 "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
15403 "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
15404
15405 appendPQExpBufferStr(query,
15406 "aggkind,\n"
15407 "aggmtransfn,\n"
15408 "aggminvtransfn,\n"
15409 "aggmfinalfn,\n"
15410 "aggmtranstype::pg_catalog.regtype,\n"
15411 "aggfinalextra,\n"
15412 "aggmfinalextra,\n"
15413 "aggtransspace,\n"
15414 "aggmtransspace,\n"
15415 "aggminitval,\n");
15416
15417 appendPQExpBufferStr(query,
15418 "aggcombinefn,\n"
15419 "aggserialfn,\n"
15420 "aggdeserialfn,\n"
15421 "proparallel,\n");
15422
15424 appendPQExpBufferStr(query,
15425 "aggfinalmodify,\n"
15426 "aggmfinalmodify\n");
15427 else
15428 appendPQExpBufferStr(query,
15429 "'0' AS aggfinalmodify,\n"
15430 "'0' AS aggmfinalmodify\n");
15431
15432 appendPQExpBufferStr(query,
15433 "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
15434 "WHERE a.aggfnoid = p.oid "
15435 "AND p.oid = $1");
15436
15438
15440 }
15441
15442 printfPQExpBuffer(query,
15443 "EXECUTE dumpAgg('%u')",
15444 agginfo->aggfn.dobj.catId.oid);
15445
15447
15450
15472
15473 {
15476
15481 }
15482
15484
15485 /* identify default modify flag for aggkind (must match DefineAggregate) */
15486 defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
15487 /* replace omitted flags for old versions */
15492
15493 /* regproc and regtype output is already sufficiently quoted */
15495 aggtransfn, aggtranstype);
15496
15498 {
15500 aggtransspace);
15501 }
15502
15504 {
15507 }
15508
15510 {
15512 aggfinalfn);
15516 {
15518 {
15521 break;
15524 break;
15527 break;
15528 default:
15530 agginfo->aggfn.dobj.name);
15531 break;
15532 }
15533 }
15534 }
15535
15538
15541
15544
15546 {
15548 aggmtransfn,
15549 aggminvtransfn,
15550 aggmtranstype);
15551 }
15552
15554 {
15556 aggmtransspace);
15557 }
15558
15560 {
15563 }
15564
15566 {
15568 aggmfinalfn);
15572 {
15574 {
15577 break;
15580 break;
15583 break;
15584 default:
15586 agginfo->aggfn.dobj.name);
15587 break;
15588 }
15589 }
15590 }
15591
15594 {
15596 aggsortconvop);
15598 }
15599
15602
15604 {
15611 agginfo->aggfn.dobj.name);
15612 }
15613
15616 aggsig);
15617
15621
15625 agginfo->aggfn.dobj.namespace->dobj.name);
15626
15629 agginfo->aggfn.dobj.dumpId,
15632 .owner = agginfo->aggfn.rolname,
15633 .description = "AGGREGATE",
15634 .section = SECTION_PRE_DATA,
15635 .createStmt = q->data,
15636 .dropStmt = delq->data));
15637
15638 /* Dump Aggregate Comments */
15641 agginfo->aggfn.dobj.namespace->dobj.name,
15642 agginfo->aggfn.rolname,
15644
15647 agginfo->aggfn.dobj.namespace->dobj.name,
15648 agginfo->aggfn.rolname,
15650
15651 /*
15652 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
15653 * command look like a function's GRANT; in particular this affects the
15654 * syntax for zero-argument aggregates and ordered-set aggregates.
15655 */
15657
15659
15663 agginfo->aggfn.dobj.namespace->dobj.name,
15665
15669
15670 PQclear(res);
15671
15672 destroyPQExpBuffer(query);
15673 destroyPQExpBuffer(q);
15675 destroyPQExpBuffer(details);
15676}
References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), _dumpOptions::dumpSchema, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fb(), fmtId(), format_aggregate_signature(), format_function_arguments(), format_function_signature(), free, getFormattedOperatorName(), InvalidDumpId, pg_fatal, PQclear, PQfnumber(), PQgetisnull, PQgetvalue, PREPQUERY_DUMPAGG, printfPQExpBuffer(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpAttrDef()
|
static |
Definition at line 18172 of file pg_dump.c.
18173{
18177 PQExpBuffer q;
18180 char *tag;
18182
18183 /* Do nothing if not dumping schema */
18185 return;
18186
18187 /* Skip if not "separate"; it was dumped in the table's definition */
18189 return;
18190
18191 q = createPQExpBuffer();
18193
18195
18197
18198 appendPQExpBuffer(q,
18199 "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
18201 adinfo->adef_expr);
18202
18206
18208
18211 ARCHIVE_OPTS(.tag = tag,
18213 .owner = tbinfo->rolname,
18214 .description = "DEFAULT",
18215 .section = SECTION_PRE_DATA,
18216 .createStmt = q->data,
18217 .dropStmt = delq->data));
18218
18219 pfree(tag);
18220 destroyPQExpBuffer(q);
18223}
References appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DUMP_COMPONENT_DEFINITION, _dumpOptions::dumpSchema, fb(), fmtId(), fmtQualifiedDumpable, pfree(), pg_free(), pg_strdup(), psprintf(), and SECTION_PRE_DATA.
Referenced by dumpDumpableObject().
◆ dumpBaseType()
Definition at line 12436 of file pg_dump.c.
12437{
12442 PGresult *res;
12445 char *typlen;
12447 char *typoutput;
12448 char *typreceive;
12449 char *typsend;
12453 char *typsubscript;
12462 char *typdelim;
12463 char *typbyval;
12465 char *typstorage;
12469
12471 {
12472 /* Set up query for type-specific details */
12473 appendPQExpBufferStr(query,
12474 "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
12475 "SELECT typlen, "
12476 "typinput, typoutput, typreceive, typsend, "
12477 "typreceive::pg_catalog.oid AS typreceiveoid, "
12478 "typsend::pg_catalog.oid AS typsendoid, "
12479 "typanalyze, "
12480 "typanalyze::pg_catalog.oid AS typanalyzeoid, "
12481 "typdelim, typbyval, typalign, typstorage, "
12482 "typmodin, typmodout, "
12483 "typmodin::pg_catalog.oid AS typmodinoid, "
12484 "typmodout::pg_catalog.oid AS typmodoutoid, "
12485 "typcategory, typispreferred, "
12486 "(typcollation <> 0) AS typcollatable, "
12487 "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
12488
12490 appendPQExpBufferStr(query,
12491 "typsubscript, "
12492 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
12493 else
12494 appendPQExpBufferStr(query,
12495 "'-' AS typsubscript, 0 AS typsubscriptoid ");
12496
12498 "WHERE oid = $1");
12499
12501
12503 }
12504
12505 printfPQExpBuffer(query,
12506 "EXECUTE dumpBaseType('%u')",
12507 tyinfo->dobj.catId.oid);
12508
12510
12520