| blob | 6c0f8278f92a0d6d7ea79d9f6599abc8e2835228 |
1 /*-------------------------------------------------------------------------
2 *
3 * pg_dump.c
4 * pg_dump is a utility for dumping out a postgres database
5 * into a script file.
6 *
7 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * pg_dump will read the system catalogs in a database and dump out a
11 * script that reproduces the schema in terms of SQL that is understood
12 * by PostgreSQL
13 *
14 * IDENTIFICATION
15 * $PostgreSQL$
16 *
17 *-------------------------------------------------------------------------
18 */
22 #include <unistd.h>
23 #include <ctype.h>
24 #ifdef ENABLE_NLS
25 #include <locale.h>
26 #endif
27 #ifdef HAVE_TERMIOS_H
28 #include <termios.h>
29 #endif
33 #ifndef HAVE_INT_OPTRESET
35 #endif
50 opterr;
54 {
62 /* global decls */
64 * activities. */
68 /* various user-settable parameters */
76 /* subquery used to convert user ID (eg, datdba) to user name */
79 /* obsolete as of 7.3: */
82 /*
83 * Object inclusion/exclusion lists
84 *
85 * The string lists record the patterns given by command-line switches,
86 * which we then convert to lists of OIDs of matching objects.
87 */
98 /* default, if no "inclusion" switches appear, is to dump everything */
103 /* placeholders for the delimiters for comments */
109 /* these are to avoid passing around info for findNamespace() */
113 /* flag to turn on/off dollar quoting */
195 ExecStatusType expected);
198 int
200 {
264 /*
265 * the following options don't have an equivalent short option letter
266 */
274 };
289 /* Set default options based on progname */
294 {
296 {
299 }
301 {
304 }
305 }
309 {
311 {
333 * attr names */
355 /* ignored, deprecated option */
380 /* no-op, still accepted for backwards compatibility */
417 /* -X is a deprecated alternative to long options */
426 else
427 {
433 }
441 /* This covers the long options equivalent to -X xxx. */
445 /* lock-wait-timeout */
452 }
453 }
456 {
460 progname);
462 }
464 /* Get database name from command line */
469 {
472 }
475 {
478 }
481 {
482 write_msg(NULL, "options -d/-D/--inserts/--column-inserts and -o/--oids cannot be used together\n");
485 }
487 /* open the output file */
489 {
490 /* This is used by pg_dumpall, and is not documented */
493 }
497 {
498 /*
499 * Dump files into the current directory; for demonstration only, not
500 * documented.
501 */
503 }
505 {
508 }
511 else
512 {
515 }
518 {
521 }
523 /* Let the archiver know how noisy to be */
528 {
531 }
533 /*
534 * We allow the server to be back to 7.0, and up to any minor release
535 * of our own major version. (See also version check in pg_dumpall.c.)
536 */
540 /*
541 * Open the database using the Archiver, so it knows about it. Errors mean
542 * death.
543 */
547 /* Set the client encoding if requested */
549 {
551 {
553 dumpencoding);
555 }
556 }
558 /*
559 * Get the active encoding and the standard_conforming_strings setting, so
560 * we know how to escape strings.
561 */
567 /* Set the datestyle to ISO to ensure the dump's portability */
570 /*
571 * If supported, set extra_float_digits so that we can dump float data
572 * exactly (given correctly implemented float I/O code, anyway)
573 */
577 /*
578 * If synchronized scanning is supported, disable it, to prevent
579 * unpredictable changes in row ordering across a dump and reload.
580 */
584 /*
585 * Disable timeouts if supported.
586 */
590 /*
591 * Start serializable transaction to dump consistent data.
592 */
597 /* Select the appropriate subquery to convert user IDs to names */
602 else
605 /* Find the last built-in OID, if needed */
607 {
610 else
614 }
616 /* Expand schema selection patterns into OID lists */
618 {
622 {
625 }
626 }
629 /* non-matching exclusion patterns aren't an error */
631 /* Expand table selection patterns into OID lists */
633 {
637 {
640 }
641 }
644 /* non-matching exclusion patterns aren't an error */
646 /*
647 * Dumping blobs is now default unless we saw an inclusion switch or -s
648 * ... but even if we did see one of these, -b turns it back on.
649 */
653 /*
654 * Now scan the database and create DumpableObject structs for all the
655 * objects we intend to dump.
656 */
663 {
667 }
670 {
671 /* Add placeholders to allow correct sorting of blobs */
685 }
687 /*
688 * Collect dependency data to assist in ordering the objects.
689 */
692 /*
693 * Sort the objects into a safe dump order (no forward references).
694 *
695 * In 7.3 or later, we can rely on dependency information to help us
696 * determine a safe order, so the initial sort is mostly for cosmetic
697 * purposes: we sort by name to ensure that logically identical schemas
698 * will dump identically. Before 7.3 we don't have dependencies and we
699 * use OID ordering as an (unreliable) guide to creation order.
700 */
705 else
710 /*
711 * Create archive TOC entries for all the objects to be dumped, in a safe
712 * order.
713 */
715 /* First the special ENCODING and STDSTRINGS entries. */
719 /* The database item is always next, unless we don't want it at all */
723 /* Now the rearrangeable objects. */
727 /*
728 * And finally we can do the actual output.
729 */
731 {
746 else
752 }
759 }
762 static void
764 {
813 }
815 void
817 {
822 }
824 /*
825 * Find the OIDs of all schemas matching the given list of patterns,
826 * and append them to the given OID list.
827 */
828 static void
830 {
831 PQExpBuffer query;
840 {
843 }
847 /*
848 * We use UNION ALL rather than UNION; this might sometimes result in
849 * duplicate entries in the OID list, but we don't care.
850 */
853 {
860 NULL);
861 }
867 {
869 }
873 }
875 /*
876 * Find the OIDs of all tables matching the given list of patterns,
877 * and append them to the given OID list.
878 */
879 static void
881 {
882 PQExpBuffer query;
892 /*
893 * We use UNION ALL rather than UNION; this might sometimes result in
894 * duplicate entries in the OID list, but we don't care.
895 */
898 {
902 "SELECT c.oid"
910 }
916 {
918 }
922 }
924 /*
925 * selectDumpableNamespace: policy-setting subroutine
926 * Mark a namespace as to be dumped or not
927 */
928 static void
930 {
931 /*
932 * If specific tables are being dumped, do not dump any complete
933 * namespaces. If specific namespaces are being dumped, dump just those
934 * namespaces. Otherwise, dump all non-system namespaces.
935 */
944 else
947 /*
948 * In any case, a namespace can be excluded by an exclusion switch
949 */
954 }
956 /*
957 * selectDumpableTable: policy-setting subroutine
958 * Mark a table as to be dumped or not
959 */
960 static void
962 {
963 /*
964 * If specific tables are being dumped, dump just those tables; else, dump
965 * according to the parent namespace's dump flag.
966 */
970 else
973 /*
974 * In any case, a table can be excluded by an exclusion switch
975 */
980 }
982 /*
983 * selectDumpableType: policy-setting subroutine
984 * Mark a type as to be dumped or not
985 */
986 static void
988 {
989 /* Dump only types in dumpable namespaces */
993 /* skip complex types, except for standalone composite types */
994 /* (note: this test should now be unnecessary) */
999 /* skip undefined placeholder types */
1003 /* skip auto-generated array types */
1007 else
1009 }
1011 /*
1012 * selectDumpableObject: policy-setting subroutine
1013 * Mark a generic dumpable object as to be dumped or not
1014 *
1015 * Use this only for object types without a special-case routine above.
1016 */
1017 static void
1019 {
1020 /*
1021 * Default policy is to dump if parent namespace is dumpable, or always
1022 * for non-namespace-associated items.
1023 */
1026 else
1028 }
1030 /*
1031 * Dump a table's contents for loading using the COPY command
1032 * - this routine is called by the Archiver when it wants the table
1033 * to be dumped.
1034 */
1036 static int
1038 {
1053 /*
1054 * Make sure we are in proper schema. We will qualify the table name
1055 * below anyway (in case its name conflicts with a pg_catalog table); but
1056 * this ensures reproducible results in case the table contains regproc,
1057 * regclass, etc columns.
1058 */
1061 /*
1062 * If possible, specify the column list explicitly so that we have no
1063 * possibility of retrieving data in the wrong column order. (The default
1064 * column ordering of COPY will not be what we want in certain corner
1065 * cases involving ADD COLUMN and inheritance.)
1066 */
1069 else
1073 {
1076 classname),
1077 column_list);
1078 }
1079 else
1080 {
1083 classname),
1084 column_list);
1085 }
1091 {
1098 {
1101 }
1103 /* ----------
1104 * THROTTLE:
1105 *
1106 * There was considerable discussion in late July, 2000 regarding
1107 * slowing down pg_dump when backing up large tables. Users with both
1108 * slow & fast (multi-processor) machines experienced performance
1109 * degradation when doing a backup.
1110 *
1111 * Initial attempts based on sleeping for a number of ms for each ms
1112 * of work were deemed too complex, then a simple 'sleep in each loop'
1113 * implementation was suggested. The latter failed because the loop
1114 * was too tight. Finally, the following was implemented:
1115 *
1116 * If throttle is non-zero, then
1117 * See how long since the last sleep.
1118 * Work out how long to sleep (based on ratio).
1119 * If sleep is more than 100ms, then
1120 * sleep
1121 * reset timer
1122 * EndIf
1123 * EndIf
1124 *
1125 * where the throttle value was the number of ms to sleep per ms of
1126 * work. The calculation was done in each loop.
1127 *
1128 * Most of the hard work is done in the backend, and this solution
1129 * still did not work particularly well: on slow machines, the ratio
1130 * was 50:1, and on medium paced machines, 1:1, and on fast
1131 * multi-processor machines, it had little or no effect, for reasons
1132 * that were unclear.
1133 *
1134 * Further discussion ensued, and the proposal was dropped.
1135 *
1136 * For those people who want this feature, it can be implemented using
1137 * gettimeofday in each loop, calculating the time since last sleep,
1138 * multiplying that by the sleep ratio, then if the result is more
1139 * than a preset 'minimum sleep time' (say 100ms), call the 'select'
1140 * function to sleep for a subsecond period ie.
1141 *
1142 * select(0, NULL, NULL, NULL, &tvi);
1143 *
1144 * This will return after the interval specified in the structure tvi.
1145 * Finally, call gettimeofday again to save the 'last sleep time'.
1146 * ----------
1147 */
1148 }
1152 {
1153 /* copy data transfer failed */
1154 write_msg(NULL, "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n", classname);
1158 }
1160 /* Check command status and return to normal libpq state */
1167 }
1169 static int
1171 {
1181 /*
1182 * Make sure we are in proper schema. We will qualify the table name
1183 * below anyway (in case its name conflicts with a pg_catalog table); but
1184 * this ensures reproducible results in case the table contains regproc,
1185 * regclass, etc columns.
1186 */
1190 {
1194 classname));
1195 }
1196 else
1197 {
1201 classname));
1202 }
1207 do
1208 {
1213 PGRES_TUPLES_OK);
1216 {
1219 {
1220 /* corner case for zero-column table */
1223 }
1225 {
1229 {
1233 }
1236 }
1239 {
1243 {
1246 }
1248 /* XXX This code is partially duplicated in ruleutils.c */
1250 {
1258 {
1259 /*
1260 * These types are printed without quotes unless
1261 * they contain values that aren't accepted by the
1262 * scanner unquoted (e.g., 'NaN'). Note that
1263 * strtod() and friends might accept NaN, so we
1264 * can't use that to test.
1265 *
1266 * In reality we only need to defend against
1267 * infinity and NaN, so we need not get too crazy
1268 * about pattern matching here.
1269 */
1274 else
1276 }
1288 else
1293 /* All other types are printed as string literals. */
1297 fout);
1300 }
1301 }
1303 }
1314 }
1317 /*
1318 * dumpTableData -
1319 * dump the contents of a single table
1320 *
1321 * Actually, this just makes an ArchiveEntry for the table contents.
1322 */
1323 static void
1325 {
1328 DataDumperPtr dumpFn;
1332 {
1333 /* Dump/restore using COPY */
1335 /* must use 2 steps here 'cause fmtId is nonreentrant */
1342 }
1343 else
1344 {
1345 /* Restore using INSERT */
1348 }
1353 NULL,
1360 }
1362 /*
1363 * getTableData -
1364 * set up dumpable objects representing the contents of tables
1365 */
1366 static void
1368 {
1372 {
1373 /* Skip VIEWs (no data to dump) */
1376 /* Skip SEQUENCEs (handled elsewhere) */
1381 {
1388 /*
1389 * Note: use tableoid 0 so that this object won't be mistaken for
1390 * something that pg_depend entries apply to.
1391 */
1402 }
1403 }
1404 }
1406 /*
1407 * getTableDataFKConstraints -
1408 * add dump-order dependencies reflecting foreign key constraints
1409 *
1410 * This code is executed only in a data-only dump --- in schema+data dumps
1411 * we handle foreign key issues by not creating the FK constraints until
1412 * after the data is loaded. In a data-only dump, however, we want to
1413 * order the table data objects in such a way that a table's referenced
1414 * tables are restored first. (In the presence of circular references or
1415 * self-references this may be impossible; we'll detect and complain about
1416 * that during the dependency sorting step.)
1417 */
1418 static void
1420 {
1425 /* Search through all the dumpable objects for FK constraints */
1428 {
1430 {
1434 /* Not interesting unless both tables are to be dumped */
1442 /*
1443 * Okay, make referencing table's TABLE_DATA object depend on
1444 * the referenced table's TABLE_DATA object.
1445 */
1448 }
1449 }
1451 }
1454 /*
1455 * guessConstraintInheritance:
1456 * In pre-8.4 databases, we can't tell for certain which constraints
1457 * are inherited. We assume a CHECK constraint is inherited if its name
1458 * matches the name of any constraint in the parent. Originally this code
1459 * tried to compare the expression texts, but that can fail for various
1460 * reasons --- for example, if the parent and child tables are in different
1461 * schemas, reverse-listing of function calls may produce different text
1462 * (schema-qualified or not) depending on search path.
1463 *
1464 * In 8.4 and up we can rely on the conislocal field to decide which
1465 * constraints must be dumped; much safer.
1466 *
1467 * This function assumes all conislocal flags were initialized to TRUE.
1468 * It clears the flag on anything that seems to be inherited.
1469 */
1470 static void
1472 {
1474 j,
1475 k;
1478 {
1484 /* Sequences and views never have parents */
1489 /* Don't bother computing anything for non-target tables, either */
1499 /* scan for inherited CHECK constraints */
1501 {
1507 {
1512 {
1516 {
1519 }
1520 }
1523 }
1524 }
1525 }
1526 }
1529 /*
1530 * dumpDatabase:
1531 * dump the database definition
1532 */
1533 static void
1535 {
1542 i_oid,
1543 i_dba,
1544 i_encoding,
1545 i_collate,
1546 i_ctype,
1547 i_tablespace;
1548 CatalogId dbCatId;
1549 DumpId dbDumpId;
1562 /* Make sure we are in proper schema */
1565 /* Get the database owner and parameters from pg_database */
1567 {
1569 "(%s datdba) as dba, "
1570 "pg_encoding_to_char(encoding) as encoding, "
1571 "datcollate, datctype, "
1572 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) as tablespace, "
1573 "shobj_description(oid, 'pg_database') as description "
1575 "FROM pg_database "
1577 username_subquery);
1579 }
1581 {
1583 "(%s datdba) as dba, "
1584 "pg_encoding_to_char(encoding) as encoding, "
1585 "NULL as datcollate, NULL as datctype, "
1586 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) as tablespace, "
1587 "shobj_description(oid, 'pg_database') as description "
1589 "FROM pg_database "
1591 username_subquery);
1593 }
1595 {
1597 "(%s datdba) as dba, "
1598 "pg_encoding_to_char(encoding) as encoding, "
1599 "NULL as datcollate, NULL as datctype, "
1600 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) as tablespace "
1601 "FROM pg_database "
1603 username_subquery);
1605 }
1607 {
1609 "(%s datdba) as dba, "
1610 "pg_encoding_to_char(encoding) as encoding, "
1611 "NULL as datcollate, NULL as datctype, "
1612 "NULL as tablespace "
1613 "FROM pg_database "
1615 username_subquery);
1617 }
1618 else
1619 {
1621 "(SELECT oid FROM pg_class WHERE relname = 'pg_database') AS tableoid, "
1622 "oid, "
1623 "(%s datdba) as dba, "
1624 "pg_encoding_to_char(encoding) as encoding, "
1625 "NULL as datcollate, NULL as datctype, "
1626 "NULL as tablespace "
1627 "FROM pg_database "
1629 username_subquery);
1631 }
1639 {
1641 datname);
1643 }
1646 {
1650 }
1671 {
1674 }
1676 {
1679 }
1681 {
1684 }
1712 /* Dump DB comment if any */
1714 {
1715 /*
1716 * 8.2 keeps comments on shared objects in a shared table, so we
1717 * cannot use the dumpComment used for other database objects.
1718 */
1722 {
1724 /* Generates warning when loaded into a differently-named database.*/
1732 }
1733 }
1734 else
1735 {
1740 }
1747 }
1750 /*
1751 * dumpEncoding: put the correct encoding into the archive
1752 */
1753 static void
1755 {
1773 }
1776 /*
1777 * dumpStdStrings: put the correct escape string behavior into the archive
1778 */
1779 static void
1781 {
1787 stdstrings);
1790 stdstrings);
1799 }
1802 /*
1803 * hasBlobs:
1804 * Test whether database contains any large objects
1805 */
1806 static bool
1808 {
1813 /* Make sure we are in proper schema */
1816 /* Check for BLOB OIDs */
1819 else
1830 }
1832 /*
1833 * dumpBlobs:
1834 * dump all blobs
1835 */
1836 static int
1838 {
1849 /* Make sure we are in proper schema */
1852 /* Cursor to get all BLOB OIDs */
1855 else
1861 /* Command to fetch from cursor */
1864 do
1865 {
1868 /* Do a fetch */
1872 /* Process the tuples, if any */
1874 {
1875 Oid blobOid;
1879 /* Open the BLOB */
1882 {
1886 }
1890 /* Now read it in chunks, sending data to archive */
1891 do
1892 {
1895 {
1899 }
1907 }
1913 }
1915 /*
1916 * dumpBlobComments
1917 * dump all blob comments
1918 *
1919 * Since we don't provide any way to be selective about dumping blobs,
1920 * there's no need to be selective about their comments either. We put
1921 * all the comments into one big TOC entry.
1922 */
1923 static int
1925 {
1935 /* Make sure we are in proper schema */
1938 /* Cursor to get all BLOB comments */
1940 blobQry = "DECLARE blobcmt CURSOR FOR SELECT loid, obj_description(loid, 'pg_largeobject') FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
1942 blobQry = "DECLARE blobcmt CURSOR FOR SELECT loid, obj_description(loid) FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
1943 else
1944 blobQry = "DECLARE blobcmt CURSOR FOR SELECT oid, (SELECT description FROM pg_description pd WHERE pd.objoid=pc.oid) FROM pg_class pc WHERE relkind = 'l'";
1949 /* Command to fetch from cursor */
1952 do
1953 {
1956 /* Do a fetch */
1960 /* Process the tuples, if any */
1962 {
1963 Oid blobOid;
1966 /* ignore blobs without comments */
1974 blobOid);
1979 }
1989 }
1991 /*
1992 * getNamespaces:
1993 * read all namespaces in the system catalogs and return them in the
1994 * NamespaceInfo* structure
1995 *
1996 * numNamespaces is set to the number of namespaces read in
1997 */
1998 NamespaceInfo *
2000 {
2004 PQExpBuffer query;
2012 /*
2013 * Before 7.3, there are no real namespaces; create two dummy entries, one
2014 * for user stuff and one for system stuff.
2015 */
2017 {
2044 }
2048 /* Make sure we are in proper schema */
2051 /*
2052 * we fetch all namespaces including system ones, so that every object we
2053 * read in can be linked to a containing namespace.
2054 */
2056 "(%s nspowner) as rolname, "
2058 username_subquery);
2074 {
2083 /* Decide whether to dump this namespace */
2089 }
2098 }
2100 /*
2101 * findNamespace:
2102 * given a namespace OID and an object OID, look up the info read by
2103 * getNamespaces
2104 *
2105 * NB: for pre-7.3 source database, we use object OID to guess whether it's
2106 * a system object or not. In 7.3 and later there is no guessing.
2107 */
2110 {
2114 {
2116 {
2121 }
2124 }
2125 else
2126 {
2127 /* This code depends on the layout set up by getNamespaces. */
2130 else
2133 }
2136 }
2138 /*
2139 * getTypes:
2140 * read all types in the system catalogs and return them in the
2141 * TypeInfo* structure
2142 *
2143 * numTypes is set to the number of types read in
2144 *
2145 * NB: this must run after getFuncs() because we assume we can do
2146 * findFuncByOid().
2147 */
2148 TypeInfo *
2150 {
2171 /*
2172 * we include even the built-in types because those may be used as array
2173 * elements by user-defined types
2174 *
2175 * we filter out the built-in types when we dump out the types
2176 *
2177 * same approach for undefined (shell) types and array types
2178 *
2179 * Note: as of 8.3 we can reliably detect whether a type is an
2180 * auto-generated array type by checking the element type's typarray.
2181 * (Before that the test is capable of generating false positives.) We
2182 * still check for name beginning with '_', though, so as to avoid the
2183 * cost of the subselect probe for all standard types. This would have to
2184 * be revisited if the backend ever allows renaming of array types.
2185 */
2187 /* Make sure we are in proper schema */
2191 {
2193 "typnamespace, "
2194 "(%s typowner) as rolname, "
2195 "typinput::oid as typinput, "
2196 "typoutput::oid as typoutput, typelem, typrelid, "
2198 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END as typrelkind, "
2199 "typtype, typisdefined, "
2200 "typname[0] = '_' AND typelem != 0 AND "
2201 "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
2203 username_subquery);
2204 }
2206 {
2208 "typnamespace, "
2209 "(%s typowner) as rolname, "
2210 "typinput::oid as typinput, "
2211 "typoutput::oid as typoutput, typelem, typrelid, "
2213 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END as typrelkind, "
2214 "typtype, typisdefined, "
2215 "typname[0] = '_' AND typelem != 0 AS isarray "
2217 username_subquery);
2218 }
2220 {
2222 "0::oid as typnamespace, "
2223 "(%s typowner) as rolname, "
2224 "typinput::oid as typinput, "
2225 "typoutput::oid as typoutput, typelem, typrelid, "
2227 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END as typrelkind, "
2228 "typtype, typisdefined, "
2229 "typname[0] = '_' AND typelem != 0 AS isarray "
2231 username_subquery);
2232 }
2233 else
2234 {
2236 "(SELECT oid FROM pg_class WHERE relname = 'pg_type') AS tableoid, "
2237 "oid, typname, "
2238 "0::oid as typnamespace, "
2239 "(%s typowner) as rolname, "
2240 "typinput::oid as typinput, "
2241 "typoutput::oid as typoutput, typelem, typrelid, "
2243 "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END as typrelkind, "
2244 "typtype, typisdefined, "
2245 "typname[0] = '_' AND typelem != 0 AS isarray "
2247 username_subquery);
2248 }
2272 {
2287 /*
2288 * If it's a table's rowtype, use special type code to facilitate
2289 * sorting into the desired order. (We don't want to consider it an
2290 * ordinary type because that would bring the table up into the
2291 * datatype part of the dump order.)
2292 */
2299 else
2304 else
2307 /* Decide whether we want to dump it */
2310 /*
2311 * If it's a domain, fetch info about its constraints, if any
2312 */
2318 /*
2319 * If it's a base type, make a DumpableObject representing a shell
2320 * definition of the type. We will need to dump that ahead of the I/O
2321 * functions for the type.
2322 *
2323 * Note: the shell type doesn't have a catId. You might think it
2324 * should copy the base type's catId, but then it might capture the
2325 * pg_depend entries for the type, which we don't want.
2326 */
2328 {
2338 /*
2339 * Initially mark the shell type as not to be dumped. We'll only
2340 * dump it if the I/O functions need to be dumped; this is taken
2341 * care of while sorting dependencies.
2342 */
2345 /*
2346 * However, if dumping from pre-7.3, there will be no dependency
2347 * info so we have to fake it here. We only need to worry about
2348 * typinput and typoutput since the other functions only exist
2349 * post-7.3.
2350 */
2352 {
2353 Oid typinput;
2354 Oid typoutput;
2362 {
2363 /* base type depends on function */
2366 /* function depends on shell type */
2369 /* mark shell type as to be dumped */
2371 }
2375 {
2376 /* base type depends on function */
2379 /* function depends on shell type */
2382 /* mark shell type as to be dumped */
2384 }
2385 }
2386 }
2391 }
2400 }
2402 /*
2403 * getOperators:
2404 * read all operators in the system catalogs and return them in the
2405 * OprInfo* structure
2406 *
2407 * numOprs is set to the number of operators read in
2408 */
2409 OprInfo *
2411 {
2424 /*
2425 * find all operators, including builtin operators; we filter out
2426 * system-defined operators at dump-out time.
2427 */
2429 /* Make sure we are in proper schema */
2433 {
2435 "oprnamespace, "
2436 "(%s oprowner) as rolname, "
2437 "oprcode::oid as oprcode "
2439 username_subquery);
2440 }
2442 {
2444 "0::oid as oprnamespace, "
2445 "(%s oprowner) as rolname, "
2446 "oprcode::oid as oprcode "
2448 username_subquery);
2449 }
2450 else
2451 {
2453 "(SELECT oid FROM pg_class WHERE relname = 'pg_operator') AS tableoid, "
2454 "oid, oprname, "
2455 "0::oid as oprnamespace, "
2456 "(%s oprowner) as rolname, "
2457 "oprcode::oid as oprcode "
2459 username_subquery);
2460 }
2478 {
2489 /* Decide whether we want to dump it */
2495 }
2502 }
2504 /*
2505 * getConversions:
2506 * read all conversions in the system catalogs and return them in the
2507 * ConvInfo* structure
2508 *
2509 * numConversions is set to the number of conversions read in
2510 */
2511 ConvInfo *
2513 {
2525 /* Conversions didn't exist pre-7.3 */
2527 {
2530 }
2532 /*
2533 * find all conversions, including builtin conversions; we filter out
2534 * system-defined conversions at dump-out time.
2535 */
2537 /* Make sure we are in proper schema */
2541 "connamespace, "
2542 "(%s conowner) as rolname "
2544 username_subquery);
2561 {
2571 /* Decide whether we want to dump it */
2573 }
2580 }
2582 /*
2583 * getOpclasses:
2584 * read all opclasses in the system catalogs and return them in the
2585 * OpclassInfo* structure
2586 *
2587 * numOpclasses is set to the number of opclasses read in
2588 */
2589 OpclassInfo *
2591 {
2603 /*
2604 * find all opclasses, including builtin opclasses; we filter out
2605 * system-defined opclasses at dump-out time.
2606 */
2608 /* Make sure we are in proper schema */
2612 {
2614 "opcnamespace, "
2615 "(%s opcowner) as rolname "
2617 username_subquery);
2618 }
2620 {
2622 "0::oid as opcnamespace, "
2623 "''::name as rolname "
2625 }
2626 else
2627 {
2629 "(SELECT oid FROM pg_class WHERE relname = 'pg_opclass') AS tableoid, "
2630 "oid, opcname, "
2631 "0::oid as opcnamespace, "
2632 "''::name as rolname "
2634 }
2651 {
2661 /* Decide whether we want to dump it */
2665 {
2669 }
2670 }
2677 }
2679 /*
2680 * getOpfamilies:
2681 * read all opfamilies in the system catalogs and return them in the
2682 * OpfamilyInfo* structure
2683 *
2684 * numOpfamilies is set to the number of opfamilies read in
2685 */
2686 OpfamilyInfo *
2688 {
2692 PQExpBuffer query;
2700 /* Before 8.3, there is no separate concept of opfamilies */
2702 {
2705 }
2709 /*
2710 * find all opfamilies, including builtin opfamilies; we filter out
2711 * system-defined opfamilies at dump-out time.
2712 */
2714 /* Make sure we are in proper schema */
2718 "opfnamespace, "
2719 "(%s opfowner) as rolname "
2721 username_subquery);
2738 {
2748 /* Decide whether we want to dump it */
2752 {
2756 }
2757 }
2764 }
2766 /*
2767 * getAggregates:
2768 * read all the user-defined aggregates in the system catalogs and
2769 * return them in the AggInfo* structure
2770 *
2771 * numAggs is set to the number of aggregates read in
2772 */
2773 AggInfo *
2775 {
2790 /* Make sure we are in proper schema */
2793 /* find all user-defined aggregates */
2796 {
2798 "pronamespace as aggnamespace, "
2799 "pronargs, proargtypes, "
2800 "(%s proowner) as rolname, "
2801 "proacl as aggacl "
2802 "FROM pg_proc "
2803 "WHERE proisagg "
2804 "AND pronamespace != "
2806 username_subquery);
2807 }
2809 {
2811 "pronamespace as aggnamespace, "
2812 "CASE WHEN proargtypes[0] = 'pg_catalog.\"any\"'::pg_catalog.regtype THEN 0 ELSE 1 END as pronargs, "
2813 "proargtypes, "
2814 "(%s proowner) as rolname, "
2815 "proacl as aggacl "
2816 "FROM pg_proc "
2817 "WHERE proisagg "
2818 "AND pronamespace != "
2820 username_subquery);
2821 }
2823 {
2825 "0::oid as aggnamespace, "
2826 "CASE WHEN aggbasetype = 0 THEN 0 ELSE 1 END as pronargs, "
2827 "aggbasetype as proargtypes, "
2828 "(%s aggowner) as rolname, "
2829 "'{=X}' as aggacl "
2830 "FROM pg_aggregate "
2832 username_subquery,
2833 g_last_builtin_oid);
2834 }
2835 else
2836 {
2838 "(SELECT oid FROM pg_class WHERE relname = 'pg_aggregate') AS tableoid, "
2839 "oid, aggname, "
2840 "0::oid as aggnamespace, "
2841 "CASE WHEN aggbasetype = 0 THEN 0 ELSE 1 END as pronargs, "
2842 "aggbasetype as proargtypes, "
2843 "(%s aggowner) as rolname, "
2844 "'{=X}' as aggacl "
2845 "FROM pg_aggregate "
2847 username_subquery,
2848 g_last_builtin_oid);
2849 }
2869 {
2887 else
2888 {
2894 else
2895 /* it's just aggbasetype */
2897 }
2899 /* Decide whether we want to dump it */
2901 }
2908 }
2910 /*
2911 * getFuncs:
2912 * read all the user-defined functions in the system catalogs and
2913 * return them in the FuncInfo* structure
2914 *
2915 * numFuncs is set to the number of functions read in
2916 */
2917 FuncInfo *
2919 {
2936 /* Make sure we are in proper schema */
2939 /* find all user-defined funcs */
2942 {
2944 "SELECT tableoid, oid, proname, prolang, "
2945 "pronargs, proargtypes, prorettype, proacl, "
2946 "pronamespace, "
2947 "(%s proowner) as rolname "
2948 "FROM pg_proc "
2949 "WHERE NOT proisagg "
2950 "AND pronamespace != "
2951 "(select oid from pg_namespace"
2953 username_subquery);
2954 }
2956 {
2958 "SELECT tableoid, oid, proname, prolang, "
2959 "pronargs, proargtypes, prorettype, "
2960 "'{=X}' as proacl, "
2961 "0::oid as pronamespace, "
2962 "(%s proowner) as rolname "
2963 "FROM pg_proc "
2965 username_subquery,
2966 g_last_builtin_oid);
2967 }
2968 else
2969 {
2971 "SELECT "
2972 "(SELECT oid FROM pg_class "
2973 " WHERE relname = 'pg_proc') AS tableoid, "
2974 "oid, proname, prolang, "
2975 "pronargs, proargtypes, prorettype, "
2976 "'{=X}' as proacl, "
2977 "0::oid as pronamespace, "
2978 "(%s proowner) as rolname "
2979 "FROM pg_proc "
2981 username_subquery,
2982 g_last_builtin_oid);
2983 }
3006 {
3022 else
3023 {
3027 }
3029 /* Decide whether we want to dump it */
3036 }
3043 }
3045 /*
3046 * getTables
3047 * read all the user-defined tables (no indexes, no catalogs)
3048 * in the system catalogs return them in the TableInfo* structure
3049 *
3050 * numTables is set to the number of tables read in
3051 */
3052 TableInfo *
3054 {
3077 /* Make sure we are in proper schema */
3080 /*
3081 * Find all the tables (including views and sequences).
3082 *
3083 * We include system catalogs, so that we can work if a user table is
3084 * defined to inherit from a system catalog (pretty weird, but...)
3085 *
3086 * We ignore tables that are not type 'r' (ordinary relation), 'S'
3087 * (sequence), 'v' (view), or 'c' (composite type).
3088 *
3089 * Composite-type table entries won't be dumped as such, but we have to
3090 * make a DumpableObject for them so that we can track dependencies of the
3091 * composite type (pg_depend entries for columns of the composite type
3092 * link to the pg_class entry not the pg_type entry).
3093 *
3094 * Note: in this phase we should collect only a minimal amount of
3095 * information about each table, basically just enough to decide if it is
3096 * interesting. We must fetch all tables in this phase because otherwise
3097 * we cannot correctly identify inherited columns, owned sequences, etc.
3098 */
3101 {
3102 /*
3103 * Left join to pick up dependency info linking sequences to their
3104 * owning column, if any (note this dependency is AUTO as of 8.2)
3105 */
3107 "SELECT c.tableoid, c.oid, relname, "
3108 "relacl, relkind, relnamespace, "
3109 "(%s relowner) as rolname, "
3110 "relchecks, reltriggers, "
3111 "relhasindex, relhasrules, relhasoids, "
3112 "d.refobjid as owning_tab, "
3113 "d.refobjsubid as owning_col, "
3114 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
3115 "array_to_string(c.reloptions, ', ') as reloptions "
3116 "from pg_class c "
3117 "left join pg_depend d on "
3118 "(c.relkind = '%c' and "
3119 "d.classid = c.tableoid and d.objid = c.oid and "
3120 "d.objsubid = 0 and "
3121 "d.refclassid = c.tableoid and d.deptype = 'a') "
3122 "where relkind in ('%c', '%c', '%c', '%c') "
3124 username_subquery,
3125 RELKIND_SEQUENCE,
3128 }
3130 {
3131 /*
3132 * Left join to pick up dependency info linking sequences to their
3133 * owning column, if any
3134 */
3136 "SELECT c.tableoid, c.oid, relname, "
3137 "relacl, relkind, relnamespace, "
3138 "(%s relowner) as rolname, "
3139 "relchecks, reltriggers, "
3140 "relhasindex, relhasrules, relhasoids, "
3141 "d.refobjid as owning_tab, "
3142 "d.refobjsubid as owning_col, "
3143 "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
3144 "NULL as reloptions "
3145 "from pg_class c "
3146 "left join pg_depend d on "
3147 "(c.relkind = '%c' and "
3148 "d.classid = c.tableoid and d.objid = c.oid and "
3149 "d.objsubid = 0 and "
3150 "d.refclassid = c.tableoid and d.deptype = 'i') "
3151 "where relkind in ('%c', '%c', '%c', '%c') "
3153 username_subquery,
3154 RELKIND_SEQUENCE,
3157 }
3159 {
3160 /*
3161 * Left join to pick up dependency info linking sequences to their
3162 * owning column, if any
3163 */
3165 "SELECT c.tableoid, c.oid, relname, "
3166 "relacl, relkind, relnamespace, "
3167 "(%s relowner) as rolname, "
3168 "relchecks, reltriggers, "
3169 "relhasindex, relhasrules, relhasoids, "
3170 "d.refobjid as owning_tab, "
3171 "d.refobjsubid as owning_col, "
3172 "NULL as reltablespace, "
3173 "NULL as reloptions "
3174 "from pg_class c "
3175 "left join pg_depend d on "
3176 "(c.relkind = '%c' and "
3177 "d.classid = c.tableoid and d.objid = c.oid and "
3178 "d.objsubid = 0 and "
3179 "d.refclassid = c.tableoid and d.deptype = 'i') "
3180 "where relkind in ('%c', '%c', '%c', '%c') "
3182 username_subquery,
3183 RELKIND_SEQUENCE,
3186 }
3188 {
3190 "SELECT tableoid, oid, relname, relacl, relkind, "
3191 "0::oid as relnamespace, "
3192 "(%s relowner) as rolname, "
3193 "relchecks, reltriggers, "
3194 "relhasindex, relhasrules, relhasoids, "
3195 "NULL::oid as owning_tab, "
3196 "NULL::int4 as owning_col, "
3197 "NULL as reltablespace, "
3198 "NULL as reloptions "
3199 "from pg_class "
3200 "where relkind in ('%c', '%c', '%c') "
3202 username_subquery,
3204 }
3206 {
3207 /* all tables have oids in 7.1 */
3209 "SELECT tableoid, oid, relname, relacl, relkind, "
3210 "0::oid as relnamespace, "
3211 "(%s relowner) as rolname, "
3212 "relchecks, reltriggers, "
3213 "relhasindex, relhasrules, "
3214 "'t'::bool as relhasoids, "
3215 "NULL::oid as owning_tab, "
3216 "NULL::int4 as owning_col, "
3217 "NULL as reltablespace, "
3218 "NULL as reloptions "
3219 "from pg_class "
3220 "where relkind in ('%c', '%c', '%c') "
3222 username_subquery,
3224 }
3225 else
3226 {
3227 /*
3228 * Before 7.1, view relkind was not set to 'v', so we must check if we
3229 * have a view by looking for a rule in pg_rewrite.
3230 */
3232 "SELECT "
3233 "(SELECT oid FROM pg_class WHERE relname = 'pg_class') AS tableoid, "
3234 "oid, relname, relacl, "
3235 "CASE WHEN relhasrules and relkind = 'r' "
3236 " and EXISTS(SELECT rulename FROM pg_rewrite r WHERE "
3237 " r.ev_class = c.oid AND r.ev_type = '1') "
3239 "ELSE relkind END AS relkind,"
3240 "0::oid as relnamespace, "
3241 "(%s relowner) as rolname, "
3242 "relchecks, reltriggers, "
3243 "relhasindex, relhasrules, "
3244 "'t'::bool as relhasoids, "
3245 "NULL::oid as owning_tab, "
3246 "NULL::int4 as owning_col, "
3247 "NULL as reltablespace, "
3248 "NULL as reloptions "
3249 "from pg_class c "
3250 "where relkind in ('%c', '%c') "
3252 RELKIND_VIEW,
3253 username_subquery,
3255 }
3264 /*
3265 * Extract data from result and lock dumpable tables. We do the locking
3266 * before anything else, to minimize the window wherein a table could
3267 * disappear under us.
3268 *
3269 * Note that we have to save info about all tables here, even when dumping
3270 * only one, because we don't yet know which tables might be inheritance
3271 * ancestors of the target table.
3272 */
3293 {
3294 /*
3295 * Arrange to fail instead of waiting forever for a table lock.
3296 *
3297 * NB: this coding assumes that the only queries issued within
3298 * the following loop are LOCK TABLEs; else the timeout may be
3299 * undesirably applied to other things too.
3300 */
3305 }
3308 {
3325 {
3328 }
3329 else
3330 {
3333 }
3337 /* other fields were zeroed above */
3339 /*
3340 * Decide whether we want to dump this table.
3341 */
3344 else
3348 /*
3349 * Read-lock target tables to make sure they aren't DROPPED or altered
3350 * in schema before we get around to dumping them.
3351 *
3352 * Note that we don't explicitly lock parents of the target tables; we
3353 * assume our lock on the child is enough to prevent schema
3354 * alterations to parent tables.
3355 *
3356 * NOTE: it'd be kinda nice to lock views and sequences too, not only
3357 * plain tables, but the backend doesn't presently allow that.
3358 */
3360 {
3367 }
3369 /* Emit notice if join for owner failed */
3373 }
3376 {
3378 }
3382 /*
3383 * Force sequences that are "owned" by table columns to be dumped whenever
3384 * their owning table is being dumped.
3385 */
3387 {
3396 /* can't use findTableByOid yet, unfortunately */
3398 {
3400 {
3402 {
3405 }
3407 }
3408 }
3409 }
3414 }
3416 /*
3417 * getInherits
3418 * read all the inheritance information
3419 * from the system catalogs return them in the InhInfo* structure
3420 *
3421 * numInherits is set to the number of pairs read in
3422 */
3423 InhInfo *
3425 {
3435 /* Make sure we are in proper schema */
3438 /* find all the inheritance information */
3455 {
3458 }
3465 }
3467 /*
3468 * getIndexes
3469 * get information about every index on a dumpable table
3470 *
3471 * Note: index data is not returned directly to the caller, but it
3472 * does get entered into the DumpableObject tables.
3473 */
3474 void
3476 {
3478 j;
3484 i_oid,
3485 i_indexname,
3486 i_indexdef,
3487 i_indnkeys,
3488 i_indkey,
3489 i_indisclustered,
3490 i_contype,
3491 i_conname,
3492 i_contableoid,
3493 i_conoid,
3494 i_tablespace,
3495 i_options;
3499 {
3502 /* Only plain tables have indexes */
3506 /* Ignore indexes of tables not to be dumped */
3514 /* Make sure we are in proper schema so indexdef is right */
3517 /*
3518 * The point of the messy-looking outer join is to find a constraint
3519 * that is related by an internal dependency link to the index. If we
3520 * find one, create a CONSTRAINT entry linked to the INDEX entry. We
3521 * assume an index won't have more than one internal dependency.
3522 */
3525 {
3527 "SELECT t.tableoid, t.oid, "
3528 "t.relname as indexname, "
3529 "pg_catalog.pg_get_indexdef(i.indexrelid) as indexdef, "
3530 "t.relnatts as indnkeys, "
3531 "i.indkey, i.indisclustered, "
3532 "c.contype, c.conname, "
3533 "c.tableoid as contableoid, "
3534 "c.oid as conoid, "
3535 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) as tablespace, "
3536 "array_to_string(t.reloptions, ', ') as options "
3537 "FROM pg_catalog.pg_index i "
3538 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
3539 "LEFT JOIN pg_catalog.pg_depend d "
3540 "ON (d.classid = t.tableoid "
3541 "AND d.objid = t.oid "
3542 "AND d.deptype = 'i') "
3543 "LEFT JOIN pg_catalog.pg_constraint c "
3544 "ON (d.refclassid = c.tableoid "
3545 "AND d.refobjid = c.oid) "
3546 "WHERE i.indrelid = '%u'::pg_catalog.oid "
3549 }
3551 {
3553 "SELECT t.tableoid, t.oid, "
3554 "t.relname as indexname, "
3555 "pg_catalog.pg_get_indexdef(i.indexrelid) as indexdef, "
3556 "t.relnatts as indnkeys, "
3557 "i.indkey, i.indisclustered, "
3558 "c.contype, c.conname, "
3559 "c.tableoid as contableoid, "
3560 "c.oid as conoid, "
3561 "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) as tablespace, "
3562 "null as options "
3563 "FROM pg_catalog.pg_index i "
3564 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
3565 "LEFT JOIN pg_catalog.pg_depend d "
3566 "ON (d.classid = t.tableoid "
3567 "AND d.objid = t.oid "
3568 "AND d.deptype = 'i') "
3569 "LEFT JOIN pg_catalog.pg_constraint c "
3570 "ON (d.refclassid = c.tableoid "
3571 "AND d.refobjid = c.oid) "
3572 "WHERE i.indrelid = '%u'::pg_catalog.oid "
3575 }
3577 {
3579 "SELECT t.tableoid, t.oid, "
3580 "t.relname as indexname, "
3581 "pg_catalog.pg_get_indexdef(i.indexrelid) as indexdef, "
3582 "t.relnatts as indnkeys, "
3583 "i.indkey, i.indisclustered, "
3584 "c.contype, c.conname, "
3585 "c.tableoid as contableoid, "
3586 "c.oid as conoid, "
3587 "NULL as tablespace, "
3588 "null as options "
3589 "FROM pg_catalog.pg_index i "
3590 "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
3591 "LEFT JOIN pg_catalog.pg_depend d "
3592 "ON (d.classid = t.tableoid "
3593 "AND d.objid = t.oid "
3594 "AND d.deptype = 'i') "
3595 "LEFT JOIN pg_catalog.pg_constraint c "
3596 "ON (d.refclassid = c.tableoid "
3597 "AND d.refobjid = c.oid) "
3598 "WHERE i.indrelid = '%u'::pg_catalog.oid "
3601 }
3603 {
3605 "SELECT t.tableoid, t.oid, "
3606 "t.relname as indexname, "
3607 "pg_get_indexdef(i.indexrelid) as indexdef, "
3608 "t.relnatts as indnkeys, "
3609 "i.indkey, false as indisclustered, "
3610 "CASE WHEN i.indisprimary THEN 'p'::char "
3611 "ELSE '0'::char END as contype, "
3612 "t.relname as conname, "
3613 "0::oid as contableoid, "
3614 "t.oid as conoid, "
3615 "NULL as tablespace, "
3616 "null as options "
3617 "FROM pg_index i, pg_class t "
3618 "WHERE t.oid = i.indexrelid "
3619 "AND i.indrelid = '%u'::oid "
3622 }
3623 else
3624 {
3626 "SELECT "
3627 "(SELECT oid FROM pg_class WHERE relname = 'pg_class') AS tableoid, "
3628 "t.oid, "
3629 "t.relname as indexname, "
3630 "pg_get_indexdef(i.indexrelid) as indexdef, "
3631 "t.relnatts as indnkeys, "
3632 "i.indkey, false as indisclustered, "
3633 "CASE WHEN i.indisprimary THEN 'p'::char "
3634 "ELSE '0'::char END as contype, "
3635 "t.relname as conname, "
3636 "0::oid as contableoid, "
3637 "t.oid as conoid, "
3638 "NULL as tablespace, "
3639 "null as options "
3640 "FROM pg_index i, pg_class t "
3641 "WHERE t.oid = i.indexrelid "
3642 "AND i.indrelid = '%u'::oid "
3645 }
3670 {
3685 /*
3686 * In pre-7.4 releases, indkeys may contain more entries than
3687 * indnkeys says (since indnkeys will be 1 for a functional
3688 * index). We don't actually care about this case since we don't
3689 * examine indkeys except for indexes associated with PRIMARY and
3690 * UNIQUE constraints, which are never functional indexes. But we
3691 * have to allocate enough space to keep parseOidArray from
3692 * complaining.
3693 */
3701 {
3702 /*
3703 * If we found a constraint matching the index, create an
3704 * entry for it.
3705 *
3706 * In a pre-7.3 database, we take this path iff the index was
3707 * marked indisprimary.
3708 */
3726 /* If pre-7.3 DB, better make sure table comes first */
3729 }
3730 else
3731 {
3732 /* Plain secondary index */
3734 }
3735 }
3738 }
3741 }
3743 /*
3744 * getConstraints
3745 *
3746 * Get info about constraints on dumpable tables.
3747 *
3748 * Currently handles foreign keys only.
3749 * Unique and primary key constraints are handled with indexes,
3750 * while check constraints are processed in getTableAttrs().
3751 */
3752 void
3754 {
3756 j;
3758 PQExpBuffer query;
3761 i_conoid,
3762 i_conname,
3763 i_confrelid,
3764 i_condef;
3767 /* pg_constraint was created in 7.3, so nothing to do if older */
3774 {
3784 /*
3785 * select table schema to ensure constraint expr is qualified if
3786 * needed
3787 */
3792 "SELECT tableoid, oid, conname, confrelid, "
3793 "pg_catalog.pg_get_constraintdef(oid) as condef "
3794 "FROM pg_catalog.pg_constraint "
3795 "WHERE conrelid = '%u'::pg_catalog.oid "
3812 {
3827 }
3830 }
3833 }
3835 /*
3836 * getDomainConstraints
3837 *
3838 * Get info about constraints on a domain.
3839 */
3840 static void
3842 {
3845 PQExpBuffer query;
3848 i_oid,
3849 i_conname,
3850 i_consrc;
3853 /* pg_constraint was created in 7.3, so nothing to do if older */
3857 /*
3858 * select appropriate schema to ensure names in constraint are properly
3859 * qualified
3860 */
3867 "pg_catalog.pg_get_constraintdef(oid) AS consrc "
3868 "FROM pg_catalog.pg_constraint "
3869 "WHERE contypid = '%u'::pg_catalog.oid "
3872 else
3874 "'CHECK (' || consrc || ')' AS consrc "
3875 "FROM pg_catalog.pg_constraint "
3876 "WHERE contypid = '%u'::pg_catalog.oid "
3896 {
3912 /*
3913 * Make the domain depend on the constraint, ensuring it won't be
3914 * output till any constraint dependencies are OK.
3915 */
3918 }
3923 }
3925 /*
3926 * getRules
3927 * get basic information about every rule in the system
3928 *
3929 * numRules is set to the number of rules read in
3930 */
3931 RuleInfo *
3933 {
3947 /* Make sure we are in proper schema */
3951 {
3953 "tableoid, oid, rulename, "
3954 "ev_class as ruletable, ev_type, is_instead, "
3955 "ev_enabled "
3956 "FROM pg_rewrite "
3958 }
3960 {
3962 "tableoid, oid, rulename, "
3963 "ev_class as ruletable, ev_type, is_instead, "
3964 "'O'::char as ev_enabled "
3965 "FROM pg_rewrite "
3967 }
3968 else
3969 {
3971 "(SELECT oid FROM pg_class WHERE relname = 'pg_rewrite') AS tableoid, "
3972 "oid, rulename, "
3973 "ev_class as ruletable, ev_type, is_instead, "
3974 "'O'::char as ev_enabled "
3975 "FROM pg_rewrite "
3977 }
3997 {
3998 Oid ruletableoid;
4008 {
4009 write_msg(NULL, "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n",
4010 ruletableoid,
4013 }
4020 {
4021 /*
4022 * If the table is a view, force its ON SELECT rule to be sorted
4023 * before the view itself --- this ensures that any dependencies
4024 * for the rule affect the table's positioning. Other rules are
4025 * forced to appear after their table.
4026 */
4029 {
4032 /* We'll merge the rule into CREATE VIEW, if possible */
4034 }
4035 else
4036 {
4040 }
4041 }
4042 else
4044 }
4051 }
4053 /*
4054 * getTriggers
4055 * get information about every trigger on a dumpable table
4056 *
4057 * Note: trigger data is not returned directly to the caller, but it
4058 * does get entered into the DumpableObject tables.
4059 */
4060 void
4062 {
4064 j;
4069 i_oid,
4070 i_tgname,
4071 i_tgfname,
4072 i_tgtype,
4073 i_tgnargs,
4074 i_tgargs,
4075 i_tgisconstraint,
4076 i_tgconstrname,
4077 i_tgconstrrelid,
4078 i_tgconstrrelname,
4079 i_tgenabled,
4080 i_tgdeferrable,
4081 i_tginitdeferred;
4085 {
4095 /*
4096 * select table schema to ensure regproc name is qualified if needed
4097 */
4102 {
4103 /*
4104 * We ignore triggers that are tied to a foreign-key constraint
4105 */
4107 "SELECT tgname, "
4108 "tgfoid::pg_catalog.regproc as tgfname, "
4109 "tgtype, tgnargs, tgargs, tgenabled, "
4110 "tgisconstraint, tgconstrname, tgdeferrable, "
4111 "tgconstrrelid, tginitdeferred, tableoid, oid, "
4112 "tgconstrrelid::pg_catalog.regclass as tgconstrrelname "
4113 "from pg_catalog.pg_trigger t "
4114 "where tgrelid = '%u'::pg_catalog.oid "
4117 }
4119 {
4120 /*
4121 * We ignore triggers that are tied to a foreign-key constraint,
4122 * but in these versions we have to grovel through pg_constraint
4123 * to find out
4124 */
4126 "SELECT tgname, "
4127 "tgfoid::pg_catalog.regproc as tgfname, "
4128 "tgtype, tgnargs, tgargs, tgenabled, "
4129 "tgisconstraint, tgconstrname, tgdeferrable, "
4130 "tgconstrrelid, tginitdeferred, tableoid, oid, "
4131 "tgconstrrelid::pg_catalog.regclass as tgconstrrelname "
4132 "from pg_catalog.pg_trigger t "
4133 "where tgrelid = '%u'::pg_catalog.oid "
4134 "and (not tgisconstraint "
4135 " OR NOT EXISTS"
4136 " (SELECT 1 FROM pg_catalog.pg_depend d "
4137 " JOIN pg_catalog.pg_constraint c ON (d.refclassid = c.tableoid AND d.refobjid = c.oid) "
4140 }
4142 {
4144 "SELECT tgname, tgfoid::regproc as tgfname, "
4145 "tgtype, tgnargs, tgargs, tgenabled, "
4146 "tgisconstraint, tgconstrname, tgdeferrable, "
4147 "tgconstrrelid, tginitdeferred, tableoid, oid, "
4148 "(select relname from pg_class where oid = tgconstrrelid) "
4149 " as tgconstrrelname "
4150 "from pg_trigger "
4153 }
4154 else
4155 {
4157 "SELECT tgname, tgfoid::regproc as tgfname, "
4158 "tgtype, tgnargs, tgargs, tgenabled, "
4159 "tgisconstraint, tgconstrname, tgdeferrable, "
4160 "tgconstrrelid, tginitdeferred, "
4161 "(SELECT oid FROM pg_class WHERE relname = 'pg_trigger') AS tableoid, "
4163 "oid, "
4164 "(select relname from pg_class where oid = tgconstrrelid) "
4165 " as tgconstrrelname "
4166 "from pg_trigger "
4169 }
4175 /*
4176 * We may have less triggers than recorded due to having ignored
4177 * foreign-key triggers
4178 */
4180 {
4184 }
4203 {
4221 {
4225 {
4227 {
4228 write_msg(NULL, "query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)\n",
4232 }
4234 }
4235 else
4237 }
4238 else
4239 {
4243 }
4244 }
4247 }
4250 }
4252 /*
4253 * getProcLangs
4254 * get basic information about every procedural language in the system
4255 *
4256 * numProcLangs is set to the number of langs read in
4257 *
4258 * NB: this must run after getFuncs() because we assume we can do
4259 * findFuncByOid().
4260 */
4261 ProcLangInfo *
4263 {
4278 /* Make sure we are in proper schema */
4282 {
4283 /* pg_language has a lanowner column */
4285 "lanname, lanpltrusted, lanplcallfoid, "
4286 "lanvalidator, lanacl, "
4287 "(%s lanowner) as lanowner "
4288 "FROM pg_language "
4289 "WHERE lanispl "
4291 username_subquery);
4292 }
4294 {
4295 /* Languages are owned by the bootstrap superuser, OID 10 */
4297 "(%s '10') as lanowner "
4298 "FROM pg_language "
4299 "WHERE lanispl "
4301 username_subquery);
4302 }
4304 {
4305 /* Languages are owned by the bootstrap superuser, sysid 1 */
4307 "(%s '1') as lanowner "
4308 "FROM pg_language "
4309 "WHERE lanispl "
4311 username_subquery);
4312 }
4314 {
4315 /* No clear notion of an owner at all before 7.4 ... */
4317 "WHERE lanispl "
4319 }
4320 else
4321 {
4323 "(SELECT oid FROM pg_class WHERE relname = 'pg_language') AS tableoid, "
4324 "oid, * FROM pg_language "
4325 "WHERE lanispl "
4327 }
4343 /* these may fail and return -1: */
4349 {
4360 else
4364 else
4368 else
4372 {
4373 /*
4374 * We need to make a dependency to ensure the function will be
4375 * dumped first. (In 7.3 and later the regular dependency
4376 * mechanism will handle this for us.)
4377 */
4383 }
4384 }
4391 }
4393 /*
4394 * getCasts
4395 * get basic information about every cast in the system
4396 *
4397 * numCasts is set to the number of casts read in
4398 */
4399 CastInfo *
4401 {
4414 /* Make sure we are in proper schema */
4418 {
4420 "castsource, casttarget, castfunc, castcontext "
4422 }
4423 else
4424 {
4426 "t1.oid as castsource, t2.oid as casttarget, "
4427 "p.oid as castfunc, 'e' as castcontext "
4428 "FROM pg_type t1, pg_type t2, pg_proc p "
4429 "WHERE p.pronargs = 1 AND "
4430 "p.proargtypes[0] = t1.oid AND "
4431 "p.prorettype = t2.oid AND p.proname = t2.typname "
4433 }
4452 {
4453 PQExpBufferData namebuf;
4466 /*
4467 * Try to name cast as concatenation of typnames. This is only used
4468 * for purposes of sorting. If we fail to find either type, the name
4469 * will be an empty string.
4470 */
4480 {
4481 /*
4482 * We need to make a dependency to ensure the function will be
4483 * dumped first. (In 7.3 and later the regular dependency
4484 * mechanism will handle this for us.)
4485 */
4492 }
4493 }
4500 }
4502 /*
4503 * getTableAttrs -
4504 * for each interesting table, read info about its attributes
4505 * (names, types, default values, CHECK constraints, etc)
4506 *
4507 * This is implemented in a very inefficient way right now, looping
4508 * through the tblinfo and doing a join per table to find the attrs and their
4509 * types. However, because we want type names and so forth to be named
4510 * relative to the schema of each table, we couldn't do it in just one
4511 * query. (Maybe one query per schema?)
4512 *
4513 * modifies tblinfo
4514 */
4515 void
4517 {
4519 j;
4537 {
4540 /* Don't bother to collect info for sequences */
4544 /* Don't bother with uninteresting tables, either */
4548 /*
4549 * Make sure we are in proper schema for this table; this allows
4550 * correct retrieval of formatted type names and default exprs
4551 */
4554 /* find all the user attributes and their types */
4556 /*
4557 * we must read the attribute names in attribute number order! because
4558 * we will use the attnum to index into the attnames array later. We
4559 * actually ask to order by "attrelid, attnum" because (at least up to
4560 * 7.3) the planner is not smart enough to realize it needn't re-sort
4561 * the output of an indexscan on pg_attribute_relid_attnum_index.
4562 */
4570 {
4571 /* need left join here to not fail on dropped columns ... */
4572 appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, a.attstattarget, a.attstorage, t.typstorage, "
4573 "a.attnotnull, a.atthasdef, a.attisdropped, a.attislocal, "
4574 "pg_catalog.format_type(t.oid,a.atttypmod) as atttypname "
4575 "from pg_catalog.pg_attribute a left join pg_catalog.pg_type t "
4576 "on a.atttypid = t.oid "
4577 "where a.attrelid = '%u'::pg_catalog.oid "
4578 "and a.attnum > 0::pg_catalog.int2 "
4581 }
4583 {
4584 /*
4585 * attstattarget doesn't exist in 7.1. It does exist in 7.2, but
4586 * we don't dump it because we can't tell whether it's been
4587 * explicitly set or was just a default.
4588 */
4589 appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, -1 as attstattarget, a.attstorage, t.typstorage, "
4590 "a.attnotnull, a.atthasdef, false as attisdropped, false as attislocal, "
4591 "format_type(t.oid,a.atttypmod) as atttypname "
4592 "from pg_attribute a left join pg_type t "
4593 "on a.atttypid = t.oid "
4594 "where a.attrelid = '%u'::oid "
4595 "and a.attnum > 0::int2 "
4598 }
4599 else
4600 {
4601 /* format_type not available before 7.1 */
4602 appendPQExpBuffer(q, "SELECT attnum, attname, atttypmod, -1 as attstattarget, attstorage, attstorage as typstorage, "
4603 "attnotnull, atthasdef, false as attisdropped, false as attislocal, "
4604 "(select typname from pg_type where oid = atttypid) as atttypname "
4605 "from pg_attribute a "
4606 "where attrelid = '%u'::oid "
4607 "and attnum > 0::int2 "
4610 }
4646 {
4648 {
4652 }
4665 /* these flags will be set in flagInhAttrs() */
4669 }
4673 /*
4674 * Get info about column defaults
4675 */
4677 {
4687 {
4689 "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc "
4690 "FROM pg_catalog.pg_attrdef "
4693 }
4695 {
4696 /* 7.2 did not have OIDs in pg_attrdef */
4698 "pg_get_expr(adbin, adrelid) AS adsrc "
4699 "FROM pg_attrdef "
4702 }
4704 {
4705 /* no pg_get_expr, so must rely on adsrc */
4707 "FROM pg_attrdef "
4710 }
4711 else
4712 {
4713 /* no pg_get_expr, no tableoid either */
4715 "(SELECT oid FROM pg_class WHERE relname = 'pg_attrdef') AS tableoid, "
4716 "oid, adnum, adsrc "
4717 "FROM pg_attrdef "
4720 }
4728 {
4744 /*
4745 * Defaults on a VIEW must always be dumped as separate ALTER
4746 * TABLE commands. Defaults on regular tables are dumped as
4747 * part of the CREATE TABLE if possible. To check if it's
4748 * safe, we mark the default as needing to appear before the
4749 * CREATE.
4750 */
4752 {
4754 /* needed in case pre-7.3 DB: */
4757 }
4758 else
4759 {
4763 }
4766 {
4770 }
4772 }
4774 }
4776 /*
4777 * Get info about table CHECK constraints
4778 */
4780 {
4790 {
4792 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
4793 "conislocal "
4794 "FROM pg_catalog.pg_constraint "
4795 "WHERE conrelid = '%u'::pg_catalog.oid "
4796 " AND contype = 'c' "
4799 }
4801 {
4803 "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
4804 "true as conislocal "
4805 "FROM pg_catalog.pg_constraint "
4806 "WHERE conrelid = '%u'::pg_catalog.oid "
4807 " AND contype = 'c' "
4810 }
4812 {
4813 /* no pg_get_constraintdef, must use consrc */
4815 "'CHECK (' || consrc || ')' AS consrc, "
4816 "true as conislocal "
4817 "FROM pg_catalog.pg_constraint "
4818 "WHERE conrelid = '%u'::pg_catalog.oid "
4819 " AND contype = 'c' "
4822 }
4824 {
4825 /* 7.2 did not have OIDs in pg_relcheck */
4827 "rcname AS conname, "
4828 "'CHECK (' || rcsrc || ')' AS consrc, "
4829 "true as conislocal "
4830 "FROM pg_relcheck "
4831 "WHERE rcrelid = '%u'::oid "
4834 }
4836 {
4838 "rcname AS conname, "
4839 "'CHECK (' || rcsrc || ')' AS consrc, "
4840 "true as conislocal "
4841 "FROM pg_relcheck "
4842 "WHERE rcrelid = '%u'::oid "
4845 }
4846 else
4847 {
4848 /* no tableoid in 7.0 */
4850 "(SELECT oid FROM pg_class WHERE relname = 'pg_relcheck') AS tableoid, "
4851 "oid, rcname AS conname, "
4852 "'CHECK (' || rcsrc || ')' AS consrc, "
4853 "true as conislocal "
4854 "FROM pg_relcheck "
4855 "WHERE rcrelid = '%u'::oid "
4858 }
4864 {
4869 }
4875 {
4893 /*
4894 * Mark the constraint as needing to appear before the table
4895 * --- this is so that any other dependencies of the
4896 * constraint will be emitted before we try to create the
4897 * table.
4898 */
4902 /*
4903 * If the constraint is inherited, this will be detected
4904 * later (in pre-8.4 databases). We also detect later if the
4905 * constraint must be split out from the table definition.
4906 */
4907 }
4909 }
4910 }
4913 }
4916 /*
4917 * getTSParsers:
4918 * read all text search parsers in the system catalogs and return them
4919 * in the TSParserInfo* structure
4920 *
4921 * numTSParsers is set to the number of parsers read in
4922 */
4923 TSParserInfo *
4925 {
4941 /* Before 8.3, there is no built-in text search support */
4943 {
4946 }
4948 /*
4949 * find all text search objects, including builtin ones; we filter out
4950 * system-defined objects at dump-out time.
4951 */
4953 /* Make sure we are in proper schema */
4957 "prsstart::oid, prstoken::oid, "
4958 "prsend::oid, prsheadline::oid, prslextype::oid "
4980 {
4994 /* Decide whether we want to dump it */
4996 }
5003 }
5005 /*
5006 * getTSDictionaries:
5007 * read all text search dictionaries in the system catalogs and return them
5008 * in the TSDictInfo* structure
5009 *
5010 * numTSDicts is set to the number of dictionaries read in
5011 */
5012 TSDictInfo *
5014 {
5028 /* Before 8.3, there is no built-in text search support */
5030 {
5033 }
5035 /* Make sure we are in proper schema */
5039 "dictnamespace, (%s dictowner) as rolname, "
5040 "dicttemplate, dictinitoption "
5042 username_subquery);
5061 {
5073 else
5076 /* Decide whether we want to dump it */
5078 }
5085 }
5087 /*
5088 * getTSTemplates:
5089 * read all text search templates in the system catalogs and return them
5090 * in the TSTemplateInfo* structure
5091 *
5092 * numTSTemplates is set to the number of templates read in
5093 */
5094 TSTemplateInfo *
5096 {
5109 /* Before 8.3, there is no built-in text search support */
5111 {
5114 }
5116 /* Make sure we are in proper schema */
5120 "tmplnamespace, tmplinit::oid, tmpllexize::oid "
5139 {
5150 /* Decide whether we want to dump it */
5152 }
5159 }
5161 /*
5162 * getTSConfigurations:
5163 * read all text search configurations in the system catalogs and return
5164 * them in the TSConfigInfo* structure
5165 *
5166 * numTSConfigs is set to the number of configurations read in
5167 */
5168 TSConfigInfo *
5170 {
5183 /* Before 8.3, there is no built-in text search support */
5185 {
5188 }
5190 /* Make sure we are in proper schema */
5194 "cfgnamespace, (%s cfgowner) as rolname, cfgparser "
5196 username_subquery);
5214 {
5225 /* Decide whether we want to dump it */
5227 }
5234 }
5237 /*
5238 * dumpComment --
5239 *
5240 * This routine is used to dump any comments associated with the
5241 * object handed to this routine. The routine takes a constant character
5242 * string for the target part of the comment-creation command, plus
5243 * the namespace and owner of the object (for labeling the ArchiveEntry),
5244 * plus catalog ID and subid which are the lookup key for pg_description,
5245 * plus the dump ID for the object (for setting a dependency).
5246 * If a matching pg_description entry is found, it is dumped.
5247 *
5248 * Note: although this routine takes a dumpId for dependency purposes,
5249 * that purpose is just to mark the dependency in the emitted dump file
5250 * for possible future use by pg_restore. We do NOT use it for determining
5251 * ordering of the comment in the dump file, because this routine is called
5252 * after dependency sorting occurs. This routine should be called just after
5253 * calling ArchiveEntry() for the specified object.
5254 */
5255 static void
5259 {
5263 /* Comments are SCHEMA not data */
5267 /* Search for comments associated with catalogId, using table */
5271 /* Is there one matching the subid? */
5273 {
5276 comments++;
5277 ncomments--;
5278 }
5280 /* If a comment exists, build COMMENT ON statement */
5282 {
5296 }
5297 }
5299 /*
5300 * dumpTableComment --
5301 *
5302 * As above, but dump comments for both the specified table (or view)
5303 * and its columns.
5304 */
5305 static void
5308 {
5311 PQExpBuffer query;
5312 PQExpBuffer target;
5314 /* Comments are SCHEMA not data */
5318 /* Search for comments associated with relation, using table */
5324 /* If comments exist, build COMMENT ON statements */
5332 {
5337 {
5350 NULL,
5355 }
5357 {
5372 NULL,
5377 }
5379 comments++;
5380 ncomments--;
5381 }
5385 }
5387 /*
5388 * findComments --
5389 *
5390 * Find the comment(s), if any, associated with the given object. All the
5391 * objsubid values associated with the given classoid/objoid are found with
5392 * one search.
5393 */
5394 static int
5397 {
5398 /* static storage for table of comments */
5407 /* Get comments if we didn't already */
5411 /*
5412 * Pre-7.2, pg_description does not contain classoid, so collectComments
5413 * just stores a zero. If there's a collision on object OID, well, you
5414 * get duplicate comments.
5415 */
5419 /*
5420 * Do binary search to find some item matching the object.
5421 */
5425 {
5436 else
5438 }
5441 {
5444 }
5446 /*
5447 * Now determine how many items match the object. The search loop
5448 * invariant still holds: only items between low and high inclusive could
5449 * match.
5450 */
5453 {
5457 middle--;
5458 nmatch++;
5459 }
5465 {
5469 middle++;
5470 nmatch++;
5471 }
5474 }
5476 /*
5477 * collectComments --
5478 *
5479 * Construct a table of all comments available for database objects.
5480 * We used to do per-object queries for the comments, but it's much faster
5481 * to pull them all over at once, and on most databases the memory cost
5482 * isn't high.
5483 *
5484 * The table is sorted by classoid/objid/objsubid for speed in lookup.
5485 */
5486 static int
5488 {
5490 PQExpBuffer query;
5499 /*
5500 * Note we do NOT change source schema here; preserve the caller's
5501 * setting, instead.
5502 */
5507 {
5509 "FROM pg_catalog.pg_description "
5511 }
5513 {
5515 "FROM pg_description "
5517 }
5518 else
5519 {
5520 /* Note: this will fail to find attribute comments in pre-7.2... */
5522 "FROM pg_description "
5524 }
5529 /* Construct lookup table containing OIDs in numeric form */
5541 {
5546 }
5548 /* Do NOT free the PGresult since we are keeping pointers into it */
5553 }
5555 /*
5556 * dumpDumpableObject
5557 *
5558 * This routine and its subsidiaries are responsible for creating
5559 * ArchiveEntries (TOC objects) for each object to be dumped.
5560 */
5561 static void
5563 {
5565 {
5624 /* table rowtypes are never dumped separately */
5652 }
5653 }
5655 /*
5656 * dumpNamespace
5657 * writes out to fout the queries to recreate a user-defined namespace
5658 */
5659 static void
5661 {
5662 PQExpBuffer q;
5663 PQExpBuffer delq;
5666 /* Skip if not to be dumped */
5670 /* don't dump dummy namespace from pre-7.3 source */
5691 /* Dump Schema Comments */
5706 }
5708 /*
5709 * dumpType
5710 * writes out to fout the queries to recreate a user-defined type
5711 */
5712 static void
5714 {
5715 /* Skip if not to be dumped */
5719 /* Dump out in proper style */
5728 }
5730 /*
5731 * dumpEnumType
5732 * writes out to fout the queries to recreate a user-defined enum type
5733 */
5734 static void
5736 {
5742 i;
5745 /* Set proper schema search path so regproc references list correctly */
5749 "WHERE enumtypid = '%u'"
5757 /* should be at least 1 value */
5759 {
5762 }
5764 /*
5765 * DROP must be fully qualified in case same name appears in pg_catalog.
5766 * CASCADE shouldn't be required here as for normal types since the I/O
5767 * functions are generic and do not get dropped.
5768 */
5776 {
5782 }
5788 NULL,
5794 /* Dump Type Comments */
5806 }
5808 /*
5809 * dumpBaseType
5810 * writes out to fout the queries to recreate a user-defined base type
5811 */
5812 static void
5814 {
5828 Oid typinputoid;
5829 Oid typoutputoid;
5830 Oid typreceiveoid;
5831 Oid typsendoid;
5832 Oid typmodinoid;
5833 Oid typmodoutoid;
5834 Oid typanalyzeoid;
5844 /* Set proper schema search path so regproc references list correctly */
5847 /* Fetch type-specific details */
5849 {
5851 "typinput, typoutput, typreceive, typsend, "
5852 "typmodin, typmodout, typanalyze, "
5853 "typinput::pg_catalog.oid as typinputoid, "
5854 "typoutput::pg_catalog.oid as typoutputoid, "
5855 "typreceive::pg_catalog.oid as typreceiveoid, "
5856 "typsend::pg_catalog.oid as typsendoid, "
5857 "typmodin::pg_catalog.oid as typmodinoid, "
5858 "typmodout::pg_catalog.oid as typmodoutoid, "
5859 "typanalyze::pg_catalog.oid as typanalyzeoid, "
5860 "typcategory, typispreferred, "
5861 "typdelim, typbyval, typalign, typstorage, "
5862 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
5863 "FROM pg_catalog.pg_type "
5866 }
5868 {
5870 "typinput, typoutput, typreceive, typsend, "
5871 "typmodin, typmodout, typanalyze, "
5872 "typinput::pg_catalog.oid as typinputoid, "
5873 "typoutput::pg_catalog.oid as typoutputoid, "
5874 "typreceive::pg_catalog.oid as typreceiveoid, "
5875 "typsend::pg_catalog.oid as typsendoid, "
5876 "typmodin::pg_catalog.oid as typmodinoid, "
5877 "typmodout::pg_catalog.oid as typmodoutoid, "
5878 "typanalyze::pg_catalog.oid as typanalyzeoid, "
5879 "'U' as typcategory, false as typispreferred, "
5880 "typdelim, typbyval, typalign, typstorage, "
5881 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
5882 "FROM pg_catalog.pg_type "
5885 }
5887 {
5889 "typinput, typoutput, typreceive, typsend, "
5890 "'-' as typmodin, '-' as typmodout, "
5891 "typanalyze, "
5892 "typinput::pg_catalog.oid as typinputoid, "
5893 "typoutput::pg_catalog.oid as typoutputoid, "
5894 "typreceive::pg_catalog.oid as typreceiveoid, "
5895 "typsend::pg_catalog.oid as typsendoid, "
5896 "0 as typmodinoid, 0 as typmodoutoid, "
5897 "typanalyze::pg_catalog.oid as typanalyzeoid, "
5898 "'U' as typcategory, false as typispreferred, "
5899 "typdelim, typbyval, typalign, typstorage, "
5900 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
5901 "FROM pg_catalog.pg_type "
5904 }
5906 {
5908 "typinput, typoutput, typreceive, typsend, "
5909 "'-' as typmodin, '-' as typmodout, "
5910 "'-' as typanalyze, "
5911 "typinput::pg_catalog.oid as typinputoid, "
5912 "typoutput::pg_catalog.oid as typoutputoid, "
5913 "typreceive::pg_catalog.oid as typreceiveoid, "
5914 "typsend::pg_catalog.oid as typsendoid, "
5915 "0 as typmodinoid, 0 as typmodoutoid, "
5916 "0 as typanalyzeoid, "
5917 "'U' as typcategory, false as typispreferred, "
5918 "typdelim, typbyval, typalign, typstorage, "
5919 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
5920 "FROM pg_catalog.pg_type "
5923 }
5925 {
5927 "typinput, typoutput, "
5928 "'-' as typreceive, '-' as typsend, "
5929 "'-' as typmodin, '-' as typmodout, "
5930 "'-' as typanalyze, "
5931 "typinput::pg_catalog.oid as typinputoid, "
5932 "typoutput::pg_catalog.oid as typoutputoid, "
5933 "0 as typreceiveoid, 0 as typsendoid, "
5934 "0 as typmodinoid, 0 as typmodoutoid, "
5935 "0 as typanalyzeoid, "
5936 "'U' as typcategory, false as typispreferred, "
5937 "typdelim, typbyval, typalign, typstorage, "
5938 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
5939 "FROM pg_catalog.pg_type "
5942 }
5944 {
5945 /*
5946 * Note: although pre-7.3 catalogs contain typreceive and typsend,
5947 * ignore them because they are not right.
5948 */
5950 "typinput, typoutput, "
5951 "'-' as typreceive, '-' as typsend, "
5952 "'-' as typmodin, '-' as typmodout, "
5953 "'-' as typanalyze, "
5954 "typinput::oid as typinputoid, "
5955 "typoutput::oid as typoutputoid, "
5956 "0 as typreceiveoid, 0 as typsendoid, "
5957 "0 as typmodinoid, 0 as typmodoutoid, "
5958 "0 as typanalyzeoid, "
5959 "'U' as typcategory, false as typispreferred, "
5960 "typdelim, typbyval, typalign, typstorage, "
5961 "NULL as typdefaultbin, typdefault "
5962 "FROM pg_type "
5965 }
5967 {
5968 /*
5969 * Ignore pre-7.2 typdefault; the field exists but has an unusable
5970 * representation.
5971 */
5973 "typinput, typoutput, "
5974 "'-' as typreceive, '-' as typsend, "
5975 "'-' as typmodin, '-' as typmodout, "
5976 "'-' as typanalyze, "
5977 "typinput::oid as typinputoid, "
5978 "typoutput::oid as typoutputoid, "
5979 "0 as typreceiveoid, 0 as typsendoid, "
5980 "0 as typmodinoid, 0 as typmodoutoid, "
5981 "0 as typanalyzeoid, "
5982 "'U' as typcategory, false as typispreferred, "
5983 "typdelim, typbyval, typalign, typstorage, "
5984 "NULL as typdefaultbin, NULL as typdefault "
5985 "FROM pg_type "
5988 }
5989 else
5990 {
5992 "typinput, typoutput, "
5993 "'-' as typreceive, '-' as typsend, "
5994 "'-' as typmodin, '-' as typmodout, "
5995 "'-' as typanalyze, "
5996 "typinput::oid as typinputoid, "
5997 "typoutput::oid as typoutputoid, "
5998 "0 as typreceiveoid, 0 as typsendoid, "
5999 "0 as typmodinoid, 0 as typmodoutoid, "
6000 "0 as typanalyzeoid, "
6001 "'U' as typcategory, false as typispreferred, "
6002 "typdelim, typbyval, typalign, "
6003 "'p'::char as typstorage, "
6004 "NULL as typdefaultbin, NULL as typdefault "
6005 "FROM pg_type "
6008 }
6013 /* Expecting a single result only */
6016 {
6020 }
6046 {
6049 }
6050 else
6053 /*
6054 * DROP must be fully qualified in case same name appears in pg_catalog.
6055 * The reason we include CASCADE is that the circular dependency between
6056 * the type and its I/O functions makes it impossible to drop the type any
6057 * other way.
6058 */
6071 {
6072 /* regproc result is correctly quoted as of 7.3 */
6085 }
6086 else
6087 {
6088 /* regproc delivers an unquoted name before 7.3 */
6089 /* cannot combine these because fmtId uses static result area */
6092 /* receive/send/typmodin/typmodout/analyze need not be printed */
6093 }
6096 {
6100 else
6102 }
6105 {
6108 /* reselect schema in case changed by function dump */
6113 }
6116 {
6119 }
6125 {
6128 }
6156 NULL,
6162 /* Dump Type Comments */
6174 }
6176 /*
6177 * dumpDomain
6178 * writes out to fout the queries to recreate a user-defined domain
6179 */
6180 static void
6182 {
6194 /* Set proper schema search path so type references list correctly */
6197 /* Fetch domain specific details */
6198 /* We assume here that remoteVersion must be at least 70300 */
6200 "pg_catalog.format_type(typbasetype, typtypmod) as typdefn, "
6201 "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) as typdefaultbin, typdefault "
6202 "FROM pg_catalog.pg_type "
6209 /* Expecting a single result only */
6212 {
6216 }
6223 {
6226 }
6227 else
6233 typdefn);
6239 {
6243 else
6245 }
6249 /*
6250 * Add any CHECK constraints for the domain
6251 */
6253 {
6259 }
6263 /*
6264 * DROP must be fully qualified in case same name appears in pg_catalog
6265 */
6274 NULL,
6280 /* Dump Domain Comments */
6291 }
6293 /*
6294 * dumpCompositeType
6295 * writes out to fout the queries to recreate a user-defined stand-alone
6296 * composite type
6297 */
6298 static void
6300 {
6310 /* Set proper schema search path so type references list correctly */
6313 /* Fetch type specific details */
6314 /* We assume here that remoteVersion must be at least 70300 */
6317 "pg_catalog.format_type(a.atttypid, a.atttypmod) as atttypdefn "
6318 "FROM pg_catalog.pg_type t, pg_catalog.pg_attribute a "
6319 "WHERE t.oid = '%u'::pg_catalog.oid "
6320 "AND a.attrelid = t.typrelid "
6321 "AND NOT a.attisdropped "
6328 /* Expecting at least a single result */
6331 {
6334 }
6343 {
6353 }
6356 /*
6357 * DROP must be fully qualified in case same name appears in pg_catalog
6358 */
6367 NULL,
6374 /* Dump Type Comments */
6386 }
6388 /*
6389 * dumpShellType
6390 * writes out to fout the queries to create a shell type
6391 *
6392 * We dump a shell definition in advance of the I/O functions for the type.
6393 */
6394 static void
6396 {
6397 PQExpBuffer q;
6399 /* Skip if not to be dumped */
6405 /*
6406 * Note the lack of a DROP command for the shell type; any required DROP
6407 * is driven off the base type entry, instead. This interacts with
6408 * _printTocEntry()'s use of the presence of a DROP command to decide
6409 * whether an entry needs an ALTER OWNER command. We don't want to alter
6410 * the shell type's owner immediately on creation; that should happen only
6411 * after it's filled in, otherwise the backend complains.
6412 */
6420 NULL,
6427 }
6429 /*
6430 * Determine whether we want to dump definitions for procedural languages.
6431 * Since the languages themselves don't have schemas, we can't rely on
6432 * the normal schema-based selection mechanism. We choose to dump them
6433 * whenever neither --schema nor --table was given. (Before 8.1, we used
6434 * the dump flag of the PL's call handler function, but in 8.1 this will
6435 * probably always be false since call handlers are created in pg_catalog.)
6436 *
6437 * For some backwards compatibility with the older behavior, we forcibly
6438 * dump a PL if its handler function (and validator if any) are in a
6439 * dumpable namespace. That case is not checked here.
6440 */
6441 static bool
6443 {
6446 /* And they're schema not data */
6450 }
6452 /*
6453 * dumpProcLang
6454 * writes out to fout the queries to recreate a user-defined
6455 * procedural language
6456 */
6457 static void
6459 {
6460 PQExpBuffer defqry;
6461 PQExpBuffer delqry;
6471 /*
6472 * Try to find the support function(s). It is not an error if we don't
6473 * find them --- if the functions are in the pg_catalog schema, as is
6474 * standard in 8.1 and up, then we won't have loaded them. (In this case
6475 * we will emit a parameterless CREATE LANGUAGE command, which will
6476 * require PL template knowledge in the backend to reload.)
6477 */
6484 {
6488 }
6490 /*
6491 * If the functions are dumpable then emit a traditional CREATE LANGUAGE
6492 * with parameters. Otherwise, dump only if shouldDumpProcLangs() says to
6493 * dump it.
6494 */
6506 /*
6507 * If dumping a HANDLER clause, treat the language as being in the handler
6508 * function's schema; this avoids cluttering the HANDLER clause. Otherwise
6509 * it doesn't really have a schema.
6510 */
6513 else
6517 qlanname);
6521 qlanname);
6523 {
6527 {
6529 /* Cope with possibility that validator is in different schema */
6535 }
6536 }
6547 /* Dump Proc Lang Comments */
6557 lanschema,
6564 }
6566 /*
6567 * format_function_arguments: generate function name and argument list
6568 *
6569 * This is used when we can rely on pg_get_function_arguments to format
6570 * the argument list.
6571 */
6573 {
6574 PQExpBufferData fn;
6579 }
6581 /*
6582 * format_function_arguments_old: generate function name and argument list
6583 *
6584 * The argument type names are qualified if needed. The function name
6585 * is never qualified.
6586 *
6587 * This is used only with pre-8.4 servers, so we aren't expecting to see
6588 * VARIADIC or TABLE arguments.
6589 *
6590 * Any or all of allargtypes, argmodes, argnames may be NULL.
6591 */
6597 {
6598 PQExpBufferData fn;
6604 {
6605 Oid typid;
6614 {
6616 {
6630 }
6631 }
6632 else
6641 argmode,
6644 typname);
6646 }
6649 }
6651 /*
6652 * format_function_signature: generate function name and argument list
6653 *
6654 * This is like format_function_arguments_old except that only a minimal
6655 * list of input argument types is generated; this is sufficient to
6656 * reference the function, but not to define it.
6657 *
6658 * If honor_quotes is false then the function name is never quoted.
6659 * This is appropriate for use in TOC tags, but not in SQL commands.
6660 */
6663 {
6664 PQExpBufferData fn;
6670 else
6673 {
6680 typname);
6682 }
6685 }
6688 /*
6689 * dumpFunc:
6690 * dump out one function
6691 */
6692 static void
6694 {
6695 PQExpBuffer query;
6696 PQExpBuffer q;
6697 PQExpBuffer delqry;
6698 PQExpBuffer asPart;
6727 /* Skip if not to be dumped */
6736 /* Set proper schema search path so type references list correctly */
6739 /* Fetch function-specific details */
6741 {
6742 /*
6743 * In 8.4 and up we rely on pg_get_function_arguments and
6744 * pg_get_function_result instead of examining proallargtypes etc.
6745 */
6747 "SELECT proretset, prosrc, probin, "
6748 "pg_catalog.pg_get_function_arguments(oid) as funcargs, "
6749 "pg_catalog.pg_get_function_result(oid) as funcresult, "
6750 "provolatile, proisstrict, prosecdef, "
6751 "proconfig, procost, prorows, "
6752 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) as lanname "
6753 "FROM pg_catalog.pg_proc "
6756 }
6758 {
6760 "SELECT proretset, prosrc, probin, "
6761 "proallargtypes, proargmodes, proargnames, "
6762 "provolatile, proisstrict, prosecdef, "
6763 "proconfig, procost, prorows, "
6764 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) as lanname "
6765 "FROM pg_catalog.pg_proc "
6768 }
6770 {
6772 "SELECT proretset, prosrc, probin, "
6773 "proallargtypes, proargmodes, proargnames, "
6774 "provolatile, proisstrict, prosecdef, "
6775 "null as proconfig, 0 as procost, 0 as prorows, "
6776 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) as lanname "
6777 "FROM pg_catalog.pg_proc "
6780 }
6782 {
6784 "SELECT proretset, prosrc, probin, "
6785 "null as proallargtypes, "
6786 "null as proargmodes, "
6787 "proargnames, "
6788 "provolatile, proisstrict, prosecdef, "
6789 "null as proconfig, 0 as procost, 0 as prorows, "
6790 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) as lanname "
6791 "FROM pg_catalog.pg_proc "
6794 }
6796 {
6798 "SELECT proretset, prosrc, probin, "
6799 "null as proallargtypes, "
6800 "null as proargmodes, "
6801 "null as proargnames, "
6802 "provolatile, proisstrict, prosecdef, "
6803 "null as proconfig, 0 as procost, 0 as prorows, "
6804 "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) as lanname "
6805 "FROM pg_catalog.pg_proc "
6808 }
6810 {
6812 "SELECT proretset, prosrc, probin, "
6813 "null as proallargtypes, "
6814 "null as proargmodes, "
6815 "null as proargnames, "
6816 "case when proiscachable then 'i' else 'v' end as provolatile, "
6817 "proisstrict, "
6818 "'f'::boolean as prosecdef, "
6819 "null as proconfig, 0 as procost, 0 as prorows, "
6820 "(SELECT lanname FROM pg_language WHERE oid = prolang) as lanname "
6821 "FROM pg_proc "
6824 }
6825 else
6826 {
6828 "SELECT proretset, prosrc, probin, "
6829 "null as proallargtypes, "
6830 "null as proargmodes, "
6831 "null as proargnames, "
6832 "case when proiscachable then 'i' else 'v' end as provolatile, "
6833 "'f'::boolean as proisstrict, "
6834 "'f'::boolean as prosecdef, "
6835 "null as proconfig, 0 as procost, 0 as prorows, "
6836 "(SELECT lanname FROM pg_language WHERE oid = prolang) as lanname "
6837 "FROM pg_proc "
6840 }
6845 /* Expecting a single result only */
6848 {
6852 }
6858 {
6862 }
6863 else
6864 {
6869 }
6878 /*
6879 * See backend/commands/functioncmds.c for details of how the 'AS' clause
6880 * is used. In 8.4 and up, an unused probin is NULL (here ""); previous
6881 * versions would set it to "-". There are no known cases in which prosrc
6882 * is unused, so the tests below for "-" are probably useless.
6883 */
6885 {
6889 {
6892 /*
6893 * where we have bin, use dollar quoting if allowed and src
6894 * contains quote or backslash; else use regular quoting.
6895 */
6899 else
6901 }
6902 }
6903 else
6904 {
6906 {
6908 /* with no bin, dollar quote src unconditionally if allowed */
6911 else
6913 }
6914 }
6919 {
6924 {
6929 }
6930 else
6932 }
6935 {
6940 {
6945 }
6946 }
6949 {
6954 {
6959 }
6960 }
6963 {
6965 {
6971 }
6972 }
6976 else
6981 /*
6982 * DROP must be fully qualified in case same name appears in pg_catalog
6983 */
6986 funcsig);
6991 else
6992 {
6996 rettypename);
6998 }
7002 {
7008 {
7012 }
7013 }
7021 /*
7022 * COST and ROWS are emitted only if present and not default, so as not to
7023 * break backwards-compatibility of the dump without need. Keep this code
7024 * in sync with the defaults in functioncmds.c.
7025 */
7027 {
7029 {
7030 /* default cost is 1 */
7033 }
7034 else
7035 {
7036 /* default cost is 100 */
7039 }
7040 }
7046 {
7047 /* we feel free to scribble on configitems[] here */
7057 /*
7058 * Some GUC variable names are 'LIST' type and hence must not be
7059 * quoted.
7060 */
7064 else
7066 }
7071 funcsig_tag,
7073 NULL,
7079 /* Dump Function Comments */
7107 }
7110 /*
7111 * Dump a user-defined cast
7112 */
7113 static void
7115 {
7116 PQExpBuffer defqry;
7117 PQExpBuffer delqry;
7118 PQExpBuffer castsig;
7127 {
7131 }
7133 /*
7134 * As per discussion we dump casts if one or more of the underlying
7135 * objects (the conversion function and the two data types) are not
7136 * builtin AND if all of the non-builtin objects are included in the dump.
7137 * Builtin meaning, the namespace name does not start with "pg_".
7138 */
7145 /*
7146 * Skip this cast if all objects are from pg_
7147 */
7154 /*
7155 * Skip cast if function isn't from pg_ and is not to be dumped.
7156 */
7162 /*
7163 * Same for the source type
7164 */
7169 /*
7170 * and the target type.
7171 */
7176 /* Make sure we are in proper schema (needed for getFormattedTypeName) */
7193 else
7194 {
7195 /*
7196 * Always qualify the function name, in case it is not in pg_catalog
7197 * schema (format_function_signature won't qualify it).
7198 */
7203 }
7222 /* Dump Cast Comments */
7234 }
7236 /*
7237 * dumpOpr
7238 * write out a single operator definition
7239 */
7240 static void
7242 {
7243 PQExpBuffer query;
7244 PQExpBuffer q;
7245 PQExpBuffer delq;
7246 PQExpBuffer oprid;
7247 PQExpBuffer details;
7272 /* Skip if not to be dumped */
7276 /*
7277 * some operators are invalid because they were the result of user
7278 * defining operators before commutators exist
7279 */
7289 /* Make sure we are in proper schema so regoperator works correctly */
7293 {
7295 "oprcode::pg_catalog.regprocedure, "
7296 "oprleft::pg_catalog.regtype, "
7297 "oprright::pg_catalog.regtype, "
7298 "oprcom::pg_catalog.regoperator, "
7299 "oprnegate::pg_catalog.regoperator, "
7300 "oprrest::pg_catalog.regprocedure, "
7301 "oprjoin::pg_catalog.regprocedure, "
7302 "oprcanmerge, oprcanhash "
7303 "from pg_catalog.pg_operator "
7306 }
7308 {
7310 "oprcode::pg_catalog.regprocedure, "
7311 "oprleft::pg_catalog.regtype, "
7312 "oprright::pg_catalog.regtype, "
7313 "oprcom::pg_catalog.regoperator, "
7314 "oprnegate::pg_catalog.regoperator, "
7315 "oprrest::pg_catalog.regprocedure, "
7316 "oprjoin::pg_catalog.regprocedure, "
7317 "(oprlsortop != 0) as oprcanmerge, "
7318 "oprcanhash "
7319 "from pg_catalog.pg_operator "
7322 }
7324 {
7326 "CASE WHEN oprleft = 0 THEN '-' "
7327 "ELSE format_type(oprleft, NULL) END as oprleft, "
7328 "CASE WHEN oprright = 0 THEN '-' "
7329 "ELSE format_type(oprright, NULL) END as oprright, "
7330 "oprcom, oprnegate, oprrest, oprjoin, "
7331 "(oprlsortop != 0) as oprcanmerge, "
7332 "oprcanhash "
7333 "from pg_operator "
7336 }
7337 else
7338 {
7340 "CASE WHEN oprleft = 0 THEN '-'::name "
7341 "ELSE (select typname from pg_type where oid = oprleft) END as oprleft, "
7342 "CASE WHEN oprright = 0 THEN '-'::name "
7343 "ELSE (select typname from pg_type where oid = oprright) END as oprright, "
7344 "oprcom, oprnegate, oprrest, oprjoin, "
7345 "(oprlsortop != 0) as oprcanmerge, "
7346 "oprcanhash "
7347 "from pg_operator "
7350 }
7355 /* Expecting a single result only */
7358 {
7362 }
7392 /*
7393 * right unary means there's a left arg and left unary means there's a
7394 * right arg
7395 */
7398 {
7401 else
7405 }
7406 else
7411 {
7414 else
7418 }
7419 else
7444 /*
7445 * DROP must be fully qualified in case same name appears in pg_catalog
7446 */
7457 NULL,
7463 /* Dump Operator Comments */
7477 }
7479 /*
7480 * Convert a function reference obtained from pg_operator
7481 *
7482 * Returns what to print, or NULL if function references is InvalidOid
7483 *
7484 * In 7.3 the input is a REGPROCEDURE display; we have to strip the
7485 * argument-types part. In prior versions, the input is a REGPROC display.
7486 */
7489 {
7490 /* In all cases "-" means a null reference */
7495 {
7501 /* find non-double-quoted left paren */
7504 {
7506 {
7509 }
7512 }
7514 }
7516 /* REGPROC before 7.3 does not quote its result */
7518 }
7520 /*
7521 * Convert an operator cross-reference obtained from pg_operator
7522 *
7523 * Returns what to print, or NULL to print nothing
7524 *
7525 * In 7.3 and up the input is a REGOPERATOR display; we have to strip the
7526 * argument-types part, and add OPERATOR() decoration if the name is
7527 * schema-qualified. In older versions, the input is just a numeric OID,
7528 * which we search our operator list for.
7529 */
7532 {
7535 /* In all cases "0" means a null reference */
7540 {
7548 /* find non-double-quoted left paren, and check for non-quoted dot */
7552 {
7558 {
7561 }
7562 }
7563 /* If not schema-qualified, don't need to add OPERATOR() */
7570 }
7574 {
7576 opr);
7578 }
7580 }
7582 /*
7583 * Convert a function OID obtained from pg_ts_parser or pg_ts_template
7584 *
7585 * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
7586 * argument lists of these functions are predetermined. Note that the
7587 * caller should ensure we are in the proper schema, because the results
7588 * are search path dependent!
7589 */
7592 {
7605 {
7609 }
7616 }
7619 /*
7620 * dumpOpclass
7621 * write out a single operator class definition
7622 */
7623 static void
7625 {
7626 PQExpBuffer query;
7627 PQExpBuffer q;
7628 PQExpBuffer delq;
7656 /* Skip if not to be dumped */
7660 /*
7661 * XXX currently we do not implement dumping of operator classes from
7662 * pre-7.3 databases. This could be done but it seems not worth the
7663 * trouble.
7664 */
7672 /* Make sure we are in proper schema so regoperator works correctly */
7675 /* Get additional fields from the pg_opclass row */
7677 {
7679 "opckeytype::pg_catalog.regtype, "
7680 "opcdefault, "
7681 "opfname AS opcfamily, "
7682 "nspname AS opcfamilynsp, "
7683 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
7684 "FROM pg_catalog.pg_opclass c "
7685 "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
7686 "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
7689 }
7690 else
7691 {
7693 "opckeytype::pg_catalog.regtype, "
7694 "opcdefault, "
7695 "NULL AS opcfamily, "
7696 "NULL AS opcfamilynsp, "
7697 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcamid) AS amname "
7698 "FROM pg_catalog.pg_opclass "
7701 }
7706 /* Expecting a single result only */
7709 {
7713 }
7727 /* amname will still be needed after we PQclear res */
7730 /*
7731 * DROP must be fully qualified in case same name appears in pg_catalog
7732 */
7740 /* Build the fixed portion of the CREATE command */
7746 opcintype,
7751 {
7756 }
7762 {
7764 opckeytype);
7766 }
7770 /*
7771 * Now fetch and print the OPERATOR entries (pg_amop rows).
7772 */
7776 {
7777 /*
7778 * Print only those opfamily members that are tied to the opclass by
7779 * pg_depend entries.
7780 *
7781 * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping
7782 * an older server's table in which it is used. Would it be better
7783 * to silently ignore it?
7784 */
7786 "amopopr::pg_catalog.regoperator "
7787 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
7788 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
7789 "AND refobjid = '%u'::pg_catalog.oid "
7790 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
7791 "AND objid = ao.oid "
7794 }
7796 {
7797 /*
7798 * Print only those opfamily members that are tied to the opclass by
7799 * pg_depend entries.
7800 */
7802 "amopopr::pg_catalog.regoperator "
7803 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
7804 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
7805 "AND refobjid = '%u'::pg_catalog.oid "
7806 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
7807 "AND objid = ao.oid "
7810 }
7811 else
7812 {
7814 "amopopr::pg_catalog.regoperator "
7815 "FROM pg_catalog.pg_amop "
7816 "WHERE amopclaid = '%u'::pg_catalog.oid "
7819 }
7831 {
7845 }
7849 /*
7850 * Now fetch and print the FUNCTION entries (pg_amproc rows).
7851 */
7855 {
7856 /*
7857 * Print only those opfamily members that are tied to the opclass by
7858 * pg_depend entries.
7859 */
7861 "amproc::pg_catalog.regprocedure "
7862 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
7863 "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
7864 "AND refobjid = '%u'::pg_catalog.oid "
7865 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
7866 "AND objid = ap.oid "
7869 }
7870 else
7871 {
7873 "amproc::pg_catalog.regprocedure "
7874 "FROM pg_catalog.pg_amproc "
7875 "WHERE amopclaid = '%u'::pg_catalog.oid "
7878 }
7889 {
7900 }
7909 NULL,
7915 /* Dump Operator Class Comments */
7929 }
7931 /*
7932 * dumpOpfamily
7933 * write out a single operator family definition
7934 */
7935 static void
7937 {
7938 PQExpBuffer query;
7939 PQExpBuffer q;
7940 PQExpBuffer delq;
7964 /* Skip if not to be dumped */
7968 /*
7969 * We want to dump the opfamily only if (1) it contains "loose" operators
7970 * or functions, or (2) it contains an opclass with a different name or
7971 * owner. Otherwise it's sufficient to let it be created during creation
7972 * of the contained opclass, and not dumping it improves portability of
7973 * the dump. Since we have to fetch the loose operators/funcs anyway, do
7974 * that first.
7975 */
7981 /* Make sure we are in proper schema so regoperator works correctly */
7984 /*
7985 * Fetch only those opfamily members that are tied directly to the
7986 * opfamily by pg_depend entries.
7987 */
7989 {
7990 /*
7991 * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping
7992 * an older server's table in which it is used. Would it be better
7993 * to silently ignore it?
7994 */
7996 "amopopr::pg_catalog.regoperator "
7997 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
7998 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
7999 "AND refobjid = '%u'::pg_catalog.oid "
8000 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
8001 "AND objid = ao.oid "
8004 }
8005 else
8006 {
8008 "amopopr::pg_catalog.regoperator "
8009 "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
8010 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
8011 "AND refobjid = '%u'::pg_catalog.oid "
8012 "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
8013 "AND objid = ao.oid "
8016 }
8024 "amproc::pg_catalog.regprocedure, "
8025 "amproclefttype::pg_catalog.regtype, "
8026 "amprocrighttype::pg_catalog.regtype "
8027 "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
8028 "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
8029 "AND refobjid = '%u'::pg_catalog.oid "
8030 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
8031 "AND objid = ap.oid "
8039 {
8040 /* No loose members, so check contained opclasses */
8044 "FROM pg_catalog.pg_opclass c, pg_catalog.pg_opfamily f, pg_catalog.pg_depend "
8045 "WHERE f.oid = '%u'::pg_catalog.oid "
8046 "AND refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
8047 "AND refobjid = f.oid "
8048 "AND classid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
8049 "AND objid = c.oid "
8050 "AND (opcname != opfname OR opcnamespace != opfnamespace OR opcowner != opfowner) "
8058 {
8059 /* no need to dump it, so bail out */
8067 }
8070 }
8072 /* Get additional fields from the pg_opfamily row */
8076 "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
8077 "FROM pg_catalog.pg_opfamily "
8084 /* Expecting a single result only */
8087 {
8091 }
8095 /* amname will still be needed after we PQclear res */
8098 /*
8099 * DROP must be fully qualified in case same name appears in pg_catalog
8100 */
8108 /* Build the fixed portion of the CREATE command */
8116 /* Do we need an ALTER to add loose members? */
8118 {
8126 /*
8127 * Now fetch and print the OPERATOR entries (pg_amop rows).
8128 */
8136 {
8150 }
8152 /*
8153 * Now fetch and print the FUNCTION entries (pg_amproc rows).
8154 */
8163 {
8174 amproc);
8177 }
8180 }
8185 NULL,
8191 /* Dump Operator Family Comments */
8207 }
8209 /*
8210 * dumpConversion
8211 * write out a single conversion definition
8212 */
8213 static void
8215 {
8216 PQExpBuffer query;
8217 PQExpBuffer q;
8218 PQExpBuffer delq;
8219 PQExpBuffer details;
8233 /* Skip if not to be dumped */
8242 /* Make sure we are in proper schema */
8245 /* Get conversion-specific details */
8247 "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
8248 "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
8249 "conproc, condefault "
8250 "FROM pg_catalog.pg_conversion c "
8257 /* Expecting a single result only */
8260 {
8264 }
8278 /*
8279 * DROP must be fully qualified in case same name appears in pg_catalog
8280 */
8292 /* regproc is automatically quoted in 7.3 and above */
8298 NULL,
8304 /* Dump Conversion Comments */
8317 }
8319 /*
8320 * format_aggregate_signature: generate aggregate name and argument list
8321 *
8322 * The argument type names are qualified if needed. The aggregate name
8323 * is never qualified.
8324 */
8327 {
8328 PQExpBufferData buf;
8335 else
8340 else
8341 {
8344 {
8351 typname);
8353 }
8355 }
8357 }
8359 /*
8360 * dumpAgg
8361 * write out a single aggregate definition
8362 */
8363 static void
8365 {
8366 PQExpBuffer query;
8367 PQExpBuffer q;
8368 PQExpBuffer delq;
8369 PQExpBuffer details;
8387 /* Skip if not to be dumped */
8396 /* Make sure we are in proper schema */
8399 /* Get aggregate-specific details */
8401 {
8403 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
8404 "aggsortop::pg_catalog.regoperator, "
8405 "agginitval, "
8406 "'t'::boolean as convertok "
8407 "from pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
8408 "where a.aggfnoid = p.oid "
8411 }
8413 {
8415 "aggfinalfn, aggtranstype::pg_catalog.regtype, "
8416 "0 as aggsortop, "
8417 "agginitval, "
8418 "'t'::boolean as convertok "
8419 "from pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
8420 "where a.aggfnoid = p.oid "
8423 }
8425 {
8427 "format_type(aggtranstype, NULL) as aggtranstype, "
8428 "0 as aggsortop, "
8429 "agginitval, "
8430 "'t'::boolean as convertok "
8431 "from pg_aggregate "
8434 }
8435 else
8436 {
8438 "aggfinalfn, "
8439 "(select typname from pg_type where oid = aggtranstype1) as aggtranstype, "
8440 "0 as aggsortop, "
8441 "agginitval1 as agginitval, "
8442 "(aggtransfn2 = 0 and aggtranstype2 = 0 and agginitval2 is null) as convertok "
8443 "from pg_aggregate "
8446 }
8451 /* Expecting a single result only */
8454 {
8458 }
8478 {
8479 write_msg(NULL, "WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n",
8480 aggsig);
8482 }
8485 {
8486 /* If using 7.3's regproc or regtype, data is already quoted */
8488 aggtransfn,
8489 aggtranstype);
8490 }
8492 {
8493 /* format_type quotes, regproc does not */
8496 aggtranstype);
8497 }
8498 else
8499 {
8500 /* need quotes all around */
8505 }
8508 {
8511 }
8514 {
8516 aggfinalfn);
8517 }
8521 {
8523 aggsortop);
8524 }
8526 /*
8527 * DROP must be fully qualified in case same name appears in pg_catalog
8528 */
8531 aggsig);
8537 aggsig_tag,
8539 NULL,
8545 /* Dump Aggregate Comments */
8552 /*
8553 * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
8554 * command look like a function's GRANT; in particular this affects the
8555 * syntax for zero-argument aggregates.
8556 */
8578 }
8580 /*
8581 * dumpTSParser
8582 * write out a single text search parser
8583 */
8584 static void
8586 {
8587 PQExpBuffer q;
8588 PQExpBuffer delq;
8590 /* Skip if not to be dumped */
8597 /* Make sure we are in proper schema */
8615 /*
8616 * DROP must be fully qualified in case same name appears in pg_catalog
8617 */
8626 NULL,
8632 /* Dump Parser Comments */
8642 }
8644 /*
8645 * dumpTSDictionary
8646 * write out a single text search dictionary
8647 */
8648 static void
8650 {
8651 PQExpBuffer q;
8652 PQExpBuffer delq;
8653 PQExpBuffer query;
8659 /* Skip if not to be dumped */
8667 /* Fetch name and namespace of the dictionary's template */
8670 "FROM pg_ts_template p, pg_namespace n "
8677 {
8681 }
8685 /* Make sure we are in proper schema */
8698 /* the dictinitoption can be dumped straight into the command */
8704 /*
8705 * DROP must be fully qualified in case same name appears in pg_catalog
8706 */
8715 NULL,
8721 /* Dump Dictionary Comments */
8732 }
8734 /*
8735 * dumpTSTemplate
8736 * write out a single text search template
8737 */
8738 static void
8740 {
8741 PQExpBuffer q;
8742 PQExpBuffer delq;
8744 /* Skip if not to be dumped */
8751 /* Make sure we are in proper schema */
8763 /*
8764 * DROP must be fully qualified in case same name appears in pg_catalog
8765 */
8774 NULL,
8780 /* Dump Template Comments */
8790 }
8792 /*
8793 * dumpTSConfig
8794 * write out a single text search configuration
8795 */
8796 static void
8798 {
8799 PQExpBuffer q;
8800 PQExpBuffer delq;
8801 PQExpBuffer query;
8806 i;
8810 /* Skip if not to be dumped */
8818 /* Fetch name and namespace of the config's parser */
8821 "FROM pg_ts_parser p, pg_namespace n "
8828 {
8832 }
8836 /* Make sure we are in proper schema */
8868 {
8874 {
8875 /* starting a new token type, so start a new command */
8880 /* tokenname needs quoting, dictname does NOT */
8883 }
8884 else
8886 }
8893 /*
8894 * DROP must be fully qualified in case same name appears in pg_catalog
8895 */
8904 NULL,
8910 /* Dump Configuration Comments */
8921 }
8924 /*----------
8925 * Write out grant/revoke information
8926 *
8927 * 'objCatId' is the catalog ID of the underlying object.
8928 * 'objDumpId' is the dump ID of the underlying object.
8929 * 'type' must be TABLE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, or TABLESPACE.
8930 * 'name' is the formatted name of the object. Must be quoted etc. already.
8931 * 'tag' is the tag for the archive entry (typ. unquoted name of object).
8932 * 'nspname' is the namespace the object is in (NULL if none).
8933 * 'owner' is the owner, NULL if there is no owner (for languages).
8934 * 'acls' is the string read out of the fooacl system catalog field;
8935 * it will be parsed here.
8936 *----------
8937 */
8938 static void
8943 {
8944 PQExpBuffer sql;
8946 /* Do nothing if ACL dump is not enabled */
8953 {
8957 }
8962 NULL,
8969 }
8971 /*
8972 * dumpTable
8973 * write out to fout the declarations (not data) of a user-defined table
8974 */
8975 static void
8977 {
8981 {
8987 /* Handle the ACL here */
8995 }
8996 }
8998 /*
8999 * dumpTableSchema
9000 * write the declaration (not data) of one user-defined table or view
9001 */
9002 static void
9004 {
9015 k;
9017 /* Make sure we are in proper schema */
9020 /* Is it a table or a view? */
9022 {
9027 /* Fetch the view definition */
9029 {
9030 /* Beginning in 7.3, viewname is not unique; rely on OID */
9034 }
9035 else
9036 {
9041 }
9047 {
9051 else
9052 write_msg(NULL, "query to obtain definition of view \"%s\" returned more than one definition\n",
9055 }
9060 {
9064 }
9066 /*
9067 * DROP must be fully qualified in case same name appears in
9068 * pg_catalog
9069 */
9079 }
9080 else
9081 {
9086 /*
9087 * DROP must be fully qualified in case same name appears in
9088 * pg_catalog
9089 */
9099 {
9100 /* Is this one of the table's own attrs, and not dropped ? */
9102 {
9103 /* Format properly if not first attr */
9108 /* Attribute name */
9112 /* Attribute type */
9114 {
9117 }
9118 else
9119 {
9120 /* If no format_type, fake it */
9124 }
9126 /*
9127 * Default value --- suppress if inherited or to be printed
9128 * separately.
9129 */
9136 /*
9137 * Not Null constraint --- suppress if inherited
9138 */
9142 actual_atts++;
9143 }
9144 }
9146 /*
9147 * Add non-inherited CHECK constraints, if any.
9148 */
9150 {
9163 actual_atts++;
9164 }
9169 {
9172 {
9182 }
9184 }
9191 /* Loop dumping statistics and storage statements */
9193 {
9194 /*
9195 * Dump per-column statistics information. We only issue an ALTER
9196 * TABLE statement if the attstattarget entry for this column is
9197 * non-negative (i.e. it's not the default value)
9198 */
9201 {
9208 }
9210 /*
9211 * Dump per-column storage information. The statement is only
9212 * dumped if the storage has been changed from the type's default.
9213 */
9215 {
9217 {
9232 }
9234 /*
9235 * Only dump the statement if it's a storage type we recognize
9236 */
9238 {
9244 storage);
9245 }
9246 }
9247 }
9248 }
9260 /* Dump Table Comments */
9263 /* Dump comments on inlined table constraints */
9265 {
9272 }
9277 }
9279 /*
9280 * dumpAttrDef --- dump an attribute's default-value declaration
9281 */
9282 static void
9284 {
9287 PQExpBuffer q;
9288 PQExpBuffer delq;
9290 /* Only print it if "separate" mode is selected */
9294 /* Don't print inherited defaults, either */
9307 /*
9308 * DROP must be fully qualified in case same name appears in pg_catalog
9309 */
9320 NULL,
9328 }
9330 /*
9331 * getAttrName: extract the correct name for an attribute
9332 *
9333 * The array tblInfo->attnames[] only provides names of user attributes;
9334 * if a system attribute number is supplied, we have to fake it.
9335 * We also do a little bit of bounds checking for safety's sake.
9336 */
9339 {
9343 {
9358 }
9363 }
9365 /*
9366 * dumpIndex
9367 * write out to fout a user-defined index
9368 */
9369 static void
9371 {
9373 PQExpBuffer q;
9374 PQExpBuffer delq;
9382 /*
9383 * If there's an associated constraint, don't dump the index per se, but
9384 * do dump any comment for it. (This is safe because dependency ordering
9385 * will have ensured the constraint is emitted first.)
9386 */
9388 {
9389 /* Plain secondary index */
9392 /* If the index is clustered, we need to record that. */
9394 {
9399 }
9401 /*
9402 * DROP must be fully qualified in case same name appears in
9403 * pg_catalog
9404 */
9418 }
9420 /* Dump Index Comments */
9431 }
9433 /*
9434 * dumpConstraint
9435 * write out to fout a user-defined constraint
9436 */
9437 static void
9439 {
9441 PQExpBuffer q;
9442 PQExpBuffer delq;
9444 /* Skip if not to be dumped */
9452 {
9453 /* Index-related constraint */
9460 {
9464 }
9473 {
9484 }
9493 /* If the index is clustered, we need to record that. */
9495 {
9500 }
9502 /*
9503 * DROP must be fully qualified in case same name appears in
9504 * pg_catalog
9505 */
9521 }
9523 {
9524 /*
9525 * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
9526 * current table data is not processed
9527 */
9534 /*
9535 * DROP must be fully qualified in case same name appears in
9536 * pg_catalog
9537 */
9548 NULL,
9553 }
9555 {
9556 /* CHECK constraint on a table */
9558 /* Ignore if not to be dumped separately */
9560 {
9561 /* not ONLY since we want it to propagate to children */
9568 /*
9569 * DROP must be fully qualified in case same name appears in
9570 * pg_catalog
9571 */
9582 NULL,
9587 }
9588 }
9590 {
9591 /* CHECK constraint on a domain */
9594 /* Ignore if not to be dumped separately */
9596 {
9603 /*
9604 * DROP must be fully qualified in case same name appears in
9605 * pg_catalog
9606 */
9617 NULL,
9622 }
9623 }
9624 else
9625 {
9628 }
9630 /* Dump Constraint Comments --- only works for table constraints */
9636 }
9638 /*
9639 * dumpTableConstraintComment --- dump a constraint's comment if any
9640 *
9641 * This is split out because we need the function in two different places
9642 * depending on whether the constraint is dumped as part of CREATE TABLE
9643 * or as a separate ALTER command.
9644 */
9645 static void
9647 {
9662 }
9664 /*
9665 * findLastBuiltInOid -
9666 * find the last built in oid
9667 *
9668 * For 7.1 and 7.2, we do this by retrieving datlastsysoid from the
9669 * pg_database entry for the current database
9670 */
9671 static Oid
9673 {
9676 Oid last_oid;
9688 {
9691 }
9693 {
9696 }
9701 }
9703 /*
9704 * findLastBuiltInOid -
9705 * find the last built in oid
9706 *
9707 * For 7.0, we do this by assuming that the last thing that initdb does is to
9708 * create the pg_indexes view. This sucks in general, but seeing that 7.0.x
9709 * initdb won't be changing anymore, it'll do.
9710 */
9711 static Oid
9713 {
9722 PGRES_TUPLES_OK);
9725 {
9728 }
9730 {
9733 }
9737 }
9739 static void
9741 {
9752 called;
9756 /* Make sure we are in proper schema */
9763 {
9765 "SELECT sequence_name, "
9766 "start_value, last_value, increment_by, "
9767 "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
9768 " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
9769 " ELSE max_value "
9770 "END AS max_value, "
9771 "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
9772 " WHEN increment_by < 0 AND min_value = %s THEN NULL "
9773 " ELSE min_value "
9774 "END AS min_value, "
9778 }
9779 else
9780 {
9782 "SELECT sequence_name, "
9783 "0 as start_value, last_value, increment_by, "
9784 "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
9785 " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
9786 " ELSE max_value "
9787 "END AS max_value, "
9788 "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
9789 " WHEN increment_by < 0 AND min_value = %s THEN NULL "
9790 " ELSE min_value "
9791 "END AS min_value, "
9795 }
9801 {
9805 }
9807 /* Disable this check: it fails if sequence has been renamed */
9808 #ifdef NOT_USED
9810 {
9814 }
9815 #endif
9828 /*
9829 * The logic we use for restoring sequences is as follows:
9830 *
9831 * Add a CREATE SEQUENCE statement as part of a "schema" dump (use
9832 * last_val for start if called is false, else use min_val for start_val).
9833 * Also, if the sequence is owned by a column, add an ALTER SEQUENCE OWNED
9834 * BY command for it.
9835 *
9836 * Add a 'SETVAL(seq, last_val, iscalled)' as part of a "data" dump.
9837 */
9839 {
9842 /*
9843 * DROP must be fully qualified in case same name appears in
9844 * pg_catalog
9845 */
9858 else
9859 {
9860 /*
9861 * Versions before 8.4 did not remember the true start value. If
9862 * is_called is false then the sequence has never been incremented
9863 * so we can use last_val. Otherwise punt and let it default.
9864 */
9867 }
9873 else
9878 else
9890 NULL,
9896 /*
9897 * If the sequence is owned by a table column, emit the ALTER for it
9898 * as a separate TOC entry immediately following the sequence's own
9899 * entry. It's OK to do this rather than using full sorting logic,
9900 * because the dependency that tells us it's owned will have forced
9901 * the table to be created first. We can't just include the ALTER in
9902 * the TOC entry because it will fail if we haven't reassigned the
9903 * sequence owner to match the table's owner.
9904 *
9905 * We need not schema-qualify the table reference because both
9906 * sequence and table must be in the same schema.
9907 */
9909 {
9913 {
9925 NULL,
9930 }
9931 }
9933 /* Dump Sequence Comments */
9939 }
9942 {
9952 NULL,
9957 }
9963 }
9965 static void
9967 {
9969 PQExpBuffer query;
9970 PQExpBuffer delqry;
9980 /*
9981 * DROP must be fully qualified in case same name appears in pg_catalog
9982 */
9991 {
9994 }
9995 else
9996 {
9999 }
10002 /* Trigger type */
10006 else
10009 {
10011 findx++;
10012 }
10014 {
10017 else
10019 findx++;
10020 }
10022 {
10025 else
10027 }
10029 {
10032 else
10034 }
10039 {
10041 {
10042 /* If we are using regclass, name is already quoted */
10046 else
10049 }
10055 else
10057 }
10061 else
10064 /* In 7.3, result of regproc is already quoted */
10068 else
10074 {
10077 /* Set 'p' to end of arg string. marked by '\000' */
10079 {
10082 {
10088 }
10089 p++;
10091 {
10092 p++;
10094 }
10097 }
10098 p--;
10102 {
10106 /*
10107 * bytea unconditionally doubles backslashes, so we suppress the
10108 * doubling for standard_conforming_strings.
10109 */
10111 s++;
10113 }
10118 }
10122 {
10126 {
10140 }
10143 }
10148 NULL,
10166 }
10168 /*
10169 * dumpRule
10170 * Dump a rule
10171 */
10172 static void
10174 {
10176 PQExpBuffer query;
10177 PQExpBuffer cmd;
10178 PQExpBuffer delcmd;
10181 /* Skip if not to be dumped */
10185 /*
10186 * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
10187 * we do not want to dump it as a separate object.
10188 */
10192 /*
10193 * Make sure we are in proper schema.
10194 */
10202 {
10206 }
10207 else
10208 {
10209 /* Rule name was unique before 7.3 ... */
10213 }
10219 {
10220 write_msg(NULL, "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n",
10223 }
10227 /*
10228 * Add the command to alter the rules replication firing semantics if it
10229 * differs from the default.
10230 */
10232 {
10238 {
10251 }
10252 }
10254 /*
10255 * DROP must be fully qualified in case same name appears in pg_catalog
10256 */
10267 NULL,
10273 /* Dump rule comments */
10289 }
10291 /*
10292 * getDependencies --- obtain available dependency data
10293 */
10294 static void
10296 {
10297 PQExpBuffer query;
10300 i;
10302 i_objid,
10303 i_refclassid,
10304 i_refobjid,
10305 i_deptype;
10309 /* No dependency info available before 7.3 */
10316 /* Make sure we are in proper schema */
10322 "classid, objid, refclassid, refobjid, deptype "
10323 "FROM pg_depend "
10324 "WHERE deptype != 'p' "
10338 /*
10339 * Since we ordered the SELECT by referencing ID, we can expect that
10340 * multiple entries for the same object will appear together; this saves
10341 * on searches.
10342 */
10346 {
10347 CatalogId objId;
10348 CatalogId refobjId;
10362 /*
10363 * Failure to find objects mentioned in pg_depend is not unexpected,
10364 * since for example we don't collect info about TOAST tables.
10365 */
10367 {
10368 #ifdef NOT_USED
10371 #endif
10373 }
10378 {
10379 #ifdef NOT_USED
10382 #endif
10384 }
10386 /*
10387 * Ordinarily, table rowtypes have implicit dependencies on their
10388 * tables. However, for a composite type the implicit dependency goes
10389 * the other way in pg_depend; which is the right thing for DROP but
10390 * it doesn't produce the dependency ordering we need. So in that one
10391 * case, we reverse the direction of the dependency.
10392 */
10397 else
10398 /* normal case */
10400 }
10405 }
10408 /*
10409 * selectSourceSchema - make the specified schema the active search path
10410 * in the source database.
10411 *
10412 * NB: pg_catalog is explicitly searched after the specified schema;
10413 * so user names are only qualified if they are cross-schema references,
10414 * and system names are only qualified if they conflict with a user name
10415 * in the current schema.
10416 *
10417 * Whenever the selected schema is not pg_catalog, be careful to qualify
10418 * references to system catalogs and types in our emitted commands!
10419 */
10420 static void
10422 {
10424 PQExpBuffer query;
10426 /* Not relevant if fetching from pre-7.3 DB */
10429 /* Ignore null schema names */
10432 /* Optimize away repeated selection of same schema */
10448 }
10450 /*
10451 * getFormattedTypeName - retrieve a nicely-formatted type name for the
10452 * given type name.
10453 *
10454 * NB: in 7.3 and up the result may depend on the currently-selected
10455 * schema; this is why we don't try to cache the names.
10456 */
10459 {
10461 PQExpBuffer query;
10466 {
10475 }
10479 {
10481 oid);
10482 }
10484 {
10486 oid);
10487 }
10488 else
10489 {
10491 "FROM pg_type "
10493 oid);
10494 }
10499 /* Expecting a single result only */
10502 {
10506 }
10509 {
10510 /* already quoted */
10512 }
10513 else
10514 {
10515 /* may need to quote it */
10517 }
10523 }
10525 /*
10526 * myFormatType --- local implementation of format_type for use with 7.0.
10527 */
10530 {
10535 /* Handle array types */
10537 {
10539 typname++;
10540 }
10542 /* Show lengths on bpchar and varchar */
10544 {
10551 }
10553 {
10558 }
10560 {
10563 {
10564 int32 tmp_typmod;
10573 }
10574 }
10576 /*
10577 * char is an internal single-byte data type; Let's make sure we force it
10578 * through with quotes. - thomas 1998-12-13
10579 */
10582 else
10585 /* Append array qualifier for array types */
10593 }
10595 /*
10596 * fmtQualifiedId - convert a qualified name to the proper format for
10597 * the source database.
10598 *
10599 * Like fmtId, use the result before calling again.
10600 */
10603 {
10608 else
10611 /* Suppress schema name if fetching from pre-7.3 DB */
10613 {
10616 }
10621 }
10623 /*
10624 * Return a column list clause for the given relation.
10625 *
10626 * Special case: if there are no undropped columns in the relation, return
10627 * "", not an invalid "()" column list.
10628 */
10631 {
10641 else
10647 {
10654 }
10661 }
10663 /*
10664 * Convenience subroutine to execute a SQL command and check for
10665 * COMMAND_OK status.
10666 */
10667 static void
10669 {
10675 }
10677 /*
10678 * Convenience subroutine to verify a SQL command succeeded,
10679 * and exit with a useful error message if not.
10680 */
10681 static void
10683 ExecStatusType expected)
10684 {
10693 else
10698 }