| blob | 7afe6e7f026352ffc2727c0fee0d9af886616e84 |
1 /*-------------------------------------------------------------------------
2 *
3 * tablecmds.c
4 * Commands for creating and altering table structures and settings
5 *
6 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
80 /*
81 * ON COMMIT action list
82 */
84 {
88 /*
89 * If this entry was created during the current transaction,
90 * creating_subid is the ID of the creating subxact; if created in a prior
91 * transaction, creating_subid is zero. If deleted during the current
92 * transaction, deleting_subid is the ID of the deleting subxact; if no
93 * deletion request is pending, deleting_subid is zero.
94 */
95 SubTransactionId creating_subid;
96 SubTransactionId deleting_subid;
102 /*
103 * State information for ALTER TABLE
104 *
105 * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
106 * structs, one for each table modified by the operation (the named table
107 * plus any child tables that are affected). We save lists of subcommands
108 * to apply to this table (possibly modified by parse transformation steps);
109 * these lists will be executed in Phase 2. If a Phase 3 step is needed,
110 * necessary information is stored in the constraints and newvals lists.
111 *
112 * Phase 2 is divided into multiple passes; subcommands are executed in
113 * a pass determined by subcommand type.
114 */
121 /* We could support a RENAME COLUMN pass here, but not currently used */
126 #define AT_NUM_PASSES 9
129 {
130 /* Information saved before any work commences: */
134 /* Information saved by Phase 1 for Phase 2: */
136 /* Information saved by Phases 1/2 for Phase 3: */
142 /* Objects to rebuild after completing ALTER TYPE operations */
149 /* Struct describing one new constraint to check in Phase 3 scan */
150 /* Note: new NOT NULL constraints are handled elsewhere */
152 {
161 /*
162 * Struct describing one new column value that needs to be computed during
163 * Phase 3 copy (this could be either a new column with a non-null default, or
164 * a column that we're changing the type of). Columns without such an entry
165 * are just copied from the old table during ATRewriteTable. Note that the
166 * expr is an expression over *old* table values.
167 */
169 {
175 /*
176 * Error-reporting support for RemoveRelations
177 */
178 struct dropmsgstrings
179 {
186 };
190 ERRCODE_UNDEFINED_TABLE,
196 ERRCODE_UNDEFINED_TABLE,
202 ERRCODE_UNDEFINED_TABLE,
208 ERRCODE_UNDEFINED_OBJECT,
214 ERRCODE_UNDEFINED_OBJECT,
220 };
253 Oid constraintOid);
288 DropBehavior behavior,
302 DropBehavior behavior,
313 Oid newOwnerId);
330 /* ----------------------------------------------------------------
331 * DefineRelation
332 * Creates a new relation.
333 *
334 * If successful, returns the OID of the new relation.
335 * ----------------------------------------------------------------
336 */
337 Oid
339 {
341 Oid namespaceId;
343 Oid relationId;
344 Oid tablespaceId;
345 Relation rel;
346 TupleDesc descriptor;
353 Datum reloptions;
355 AttrNumber attnum;
358 /*
359 * Truncate relname to appropriate length (probably a waste of time, as
360 * parser should have done this already).
361 */
364 /*
365 * Check consistency of arguments
366 */
372 /*
373 * Look up the namespace in which we are supposed to create the relation.
374 * Check we have permission to create there. Skip check if bootstrapping,
375 * since permissions machinery may not be working yet.
376 */
380 {
381 AclResult aclresult;
384 ACL_CREATE);
388 }
390 /*
391 * Select tablespace to use. If not specified, use default tablespace
392 * (which may in turn default to database's default).
393 */
395 {
402 }
403 else
404 {
406 /* note InvalidOid is OK in this case */
407 }
409 /* Check permissions except when using database's default */
411 {
412 AclResult aclresult;
415 ACL_CREATE);
419 }
421 /*
422 * Parse and validate reloptions, if any.
423 */
429 /*
430 * Look up inheritance ancestors and generate relation schema, including
431 * inherited attributes.
432 */
437 /*
438 * Create a tuple descriptor from the relation schema. Note that this
439 * deals with column names, types, and NOT NULL constraints, but not
440 * default values or CHECK constraints; we handle those below.
441 */
447 /*
448 * Find columns with default values and prepare for insertion of the
449 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
450 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
451 * while raw defaults go into a list of RawColumnDefault structs that will
452 * be processed by AddRelationNewConstraints. (We can't deal with raw
453 * expressions until we can do transformExpr.)
454 *
455 * We can set the atthasdef flags now in the tuple descriptor; this just
456 * saves StoreAttrDefault from having to do an immediate update of the
457 * pg_attribute rows.
458 */
464 {
467 attnum++;
470 {
480 }
482 {
494 }
495 }
497 /*
498 * Create the relation. Inherited defaults and constraints are passed in
499 * for immediate handling --- since they don't need parsing, they can be
500 * stored immediately.
501 */
503 namespaceId,
504 tablespaceId,
505 InvalidOid,
507 descriptor,
509 old_constraints),
510 relkind,
512 localHasOids,
513 parentOidCount,
515 reloptions,
516 allowSystemTableMods);
520 /*
521 * We must bump the command counter to make the newly-created relation
522 * tuple visible for opening.
523 */
526 /*
527 * Open the new relation and acquire exclusive lock on it. This isn't
528 * really necessary for locking out other backends (since they can't see
529 * the new rel anyway until we commit), but it keeps the lock manager from
530 * complaining about deadlock risks.
531 */
534 /*
535 * Now add any newly specified column default values and CHECK constraints
536 * to the new relation. These are passed to us in the form of raw
537 * parsetrees; we need to transform them to executable expression trees
538 * before they can be added. The most convenient way to do that is to
539 * apply the parser's transformExpr routine, but transformExpr doesn't
540 * work unless we have a pre-existing relation. So, the transformation has
541 * to be postponed to this final step of CREATE TABLE.
542 */
547 /*
548 * Clean up. We keep lock on new relation (although it shouldn't be
549 * visible to anyone else anyway, until commit).
550 */
554 }
556 /*
557 * Emit the right error or warning message for a "DROP" command issued on a
558 * non-existent relation
559 */
560 static void
562 {
566 {
568 {
570 {
574 }
575 else
576 {
579 }
580 }
581 }
584 }
586 /*
587 * Emit the right error message for a "DROP" command issued on a
588 * relation of the wrong type
589 */
590 static void
592 {
604 /* wrongkind could be something we don't have in our table... */
610 }
612 /*
613 * RemoveRelations
614 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW
615 */
616 void
618 {
623 /*
624 * First we identify all the relations, then we delete them in a single
625 * performMultipleDeletions() call. This is to avoid unwanted DROP
626 * RESTRICT errors if one of the relations depends on another.
627 */
629 /* Determine required relkind */
631 {
653 }
655 /* Lock and validate each relation; build a list of object addresses */
659 {
661 Oid relOid;
662 HeapTuple tuple;
663 Form_pg_class classform;
664 ObjectAddress obj;
666 /*
667 * These next few steps are a great deal like relation_openrv, but we
668 * don't bother building a relcache entry since we don't need it.
669 *
670 * Check for shared-cache-inval messages before trying to access the
671 * relation. This is needed to cover the case where the name
672 * identifies a rel that has been dropped and recreated since the
673 * start of our transaction: if we don't flush the old syscache entry,
674 * then we'll latch onto that entry and suffer an error later.
675 */
678 /* Look up the appropriate relation using namespace search */
681 /* Not there? */
683 {
686 }
688 /*
689 * In DROP INDEX, attempt to acquire lock on the parent table before
690 * locking the index. index_drop() will need this anyway, and since
691 * regular queries lock tables before their indexes, we risk deadlock
692 * if we do it the other way around. No error if we don't find a
693 * pg_index entry, though --- that most likely means it isn't an
694 * index, and we'll fail below.
695 */
697 {
702 {
707 }
708 }
710 /* Get the lock before trying to fetch the syscache entry */
723 /* Allow DROP to either table owner or schema owner */
735 /* OK, we're ready to delete this one */
743 }
748 }
750 /*
751 * ExecuteTruncate
752 * Executes a TRUNCATE command.
753 *
754 * This is a multi-relation truncate. We first open and grab exclusive
755 * lock on all relations involved, checking permissions and otherwise
756 * verifying that the relation is OK for truncation. In CASCADE mode,
757 * relations having FK references to the targeted relations are automatically
758 * added to the group; in RESTRICT mode, we check that all FK references are
759 * internal to the group that's being truncated. Finally all the relations
760 * are truncated and reindexed.
761 */
762 void
764 {
773 /*
774 * Open, exclusive-lock, and check all the explicitly-specified relations
775 */
777 {
779 Relation rel;
781 Oid myrelid;
785 /* don't throw error for "TRUNCATE foo, foo" */
787 {
790 }
796 {
803 {
809 /* find_all_inheritors already got lock */
814 }
815 }
816 }
818 /*
819 * In CASCADE mode, suck in all referencing relations as well. This
820 * requires multiple iterations to find indirectly-dependent relations. At
821 * each phase, we need to exclusive-lock new rels before looking for their
822 * dependencies, else we might miss something. Also, we check each rel as
823 * soon as we open it, to avoid a faux pas such as holding lock for a long
824 * time on a rel we have no permissions for.
825 */
827 {
829 {
837 {
839 Relation rel;
848 }
849 }
850 }
852 /*
853 * Check foreign key references. In CASCADE mode, this should be
854 * unnecessary since we just pulled in all the references; but as a
855 * cross-check, do it anyway if in an Assert-enabled build.
856 */
857 #ifdef USE_ASSERT_CHECKING
859 #else
862 #endif
864 /*
865 * If we are asked to restart sequences, find all the sequences, lock them
866 * (we only need AccessShareLock because that's all that ALTER SEQUENCE
867 * takes), and check permissions. We want to do this early since it's
868 * pointless to do all the truncation work only to fail on sequence
869 * permissions.
870 */
872 {
874 {
880 {
882 Relation seq_rel;
886 /* This check must match AlterSequence! */
894 }
895 }
896 }
898 /* Prepare to catch AFTER triggers. */
901 /*
902 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
903 * each relation.
904 */
910 {
914 rel,
918 resultRelInfo++;
919 }
923 /*
924 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
925 * truncating (this is because one of them might throw an error). Also, if
926 * we were to allow them to prevent statement execution, that would need
927 * to be handled here.
928 */
931 {
934 resultRelInfo++;
935 }
937 /*
938 * OK, truncate each table.
939 */
941 {
943 Oid heap_relid;
944 Oid toast_relid;
946 /*
947 * Create a new empty storage file for the relation, and assign it as
948 * the relfilenode value. The old storage file is scheduled for
949 * deletion at commit.
950 */
956 /*
957 * The same for the toast table, if any.
958 */
960 {
964 }
966 /*
967 * Reconstruct the indexes to match, and we're done.
968 */
970 }
972 /*
973 * Process all AFTER STATEMENT TRUNCATE triggers.
974 */
977 {
980 resultRelInfo++;
981 }
983 /* Handle queued AFTER triggers */
986 /* We can clean up the EState now */
989 /* And close the rels (can't do this while EState still holds refs) */
991 {
995 }
997 /*
998 * Lastly, restart any owned sequences if we were asked to. This is done
999 * last because it's nontransactional: restarts will not roll back if we
1000 * abort later. Hence it's important to postpone them as long as
1001 * possible. (This is also a big reason why we locked and
1002 * permission-checked the sequences beforehand.)
1003 */
1005 {
1009 {
1013 }
1014 }
1015 }
1017 /*
1018 * Check that a given rel is safe to truncate. Subroutine for ExecuteTruncate
1019 */
1020 static void
1022 {
1023 AclResult aclresult;
1025 /* Only allow truncate on regular tables */
1032 /* Permissions checks */
1034 ACL_TRUNCATE);
1045 /*
1046 * We can never allow truncation of shared or nailed-in-cache relations,
1047 * because we can't support changing their relfilenode values.
1048 */
1055 /*
1056 * Don't allow truncate on temp tables of other backends ... their local
1057 * buffer manager is not going to cope.
1058 */
1064 /*
1065 * Also check for active uses of the relation in the current transaction,
1066 * including open scans and pending AFTER trigger events.
1067 */
1069 }
1071 /*----------
1072 * MergeAttributes
1073 * Returns new schema given initial schema and superclasses.
1074 *
1075 * Input arguments:
1076 * 'schema' is the column/attribute definition for the table. (It's a list
1077 * of ColumnDef's.) It is destructively changed.
1078 * 'supers' is a list of names (as RangeVar nodes) of parent relations.
1079 * 'istemp' is TRUE if we are creating a temp relation.
1080 *
1081 * Output arguments:
1082 * 'supOids' receives a list of the OIDs of the parent relations.
1083 * 'supconstr' receives a list of constraints belonging to the parents,
1084 * updated as necessary to be valid for the child.
1085 * 'supOidCount' is set to the number of parents that have OID columns.
1086 *
1087 * Return value:
1088 * Completed schema list.
1089 *
1090 * Notes:
1091 * The order in which the attributes are inherited is very important.
1092 * Intuitively, the inherited attributes should come first. If a table
1093 * inherits from multiple parents, the order of those attributes are
1094 * according to the order of the parents specified in CREATE TABLE.
1095 *
1096 * Here's an example:
1097 *
1098 * create table person (name text, age int4, location point);
1099 * create table emp (salary int4, manager text) inherits(person);
1100 * create table student (gpa float8) inherits (person);
1101 * create table stud_emp (percent int4) inherits (emp, student);
1102 *
1103 * The order of the attributes of stud_emp is:
1104 *
1105 * person {1:name, 2:age, 3:location}
1106 * / \
1107 * {6:gpa} student emp {4:salary, 5:manager}
1108 * \ /
1109 * stud_emp {7:percent}
1110 *
1111 * If the same attribute name appears multiple times, then it appears
1112 * in the result table in the proper location for its first appearance.
1113 *
1114 * Constraints (including NOT NULL constraints) for the child table
1115 * are the union of all relevant constraints, from both the child schema
1116 * and parent tables.
1117 *
1118 * The default value for a child column is defined as:
1119 * (1) If the child schema specifies a default, that value is used.
1120 * (2) If neither the child nor any parent specifies a default, then
1121 * the column will not have a default.
1122 * (3) If conflicting defaults are inherited from different parents
1123 * (and not overridden by the child), an error is raised.
1124 * (4) Otherwise the inherited default is used.
1125 * Rule (3) is new in Postgres 7.1; in earlier releases you got a
1126 * rather arbitrary choice of which parent default to use.
1127 *----------
1128 */
1132 {
1142 /*
1143 * Check for and reject tables with too many columns. We perform this
1144 * check relatively early for two reasons: (a) we don't run the risk of
1145 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
1146 * okay if we're processing <= 1600 columns, but could take minutes to
1147 * execute if the user attempts to create a table with hundreds of
1148 * thousands of columns.
1149 *
1150 * Note that we also need to check that any we do not exceed this figure
1151 * after including columns from inherited relations.
1152 */
1157 MaxHeapAttributeNumber)));
1159 /*
1160 * Check for duplicate names in the explicit list of attributes.
1161 *
1162 * Although we might consider merging such entries in the same way that we
1163 * handle name conflicts for inherited attributes, it seems to make more
1164 * sense to assume such conflicts are errors.
1165 */
1167 {
1172 {
1180 }
1181 }
1183 /*
1184 * Scan the parents left-to-right, and merge their attributes to form a
1185 * list of inherited attributes (inhSchema). Also check to see if we need
1186 * to inherit an OID column.
1187 */
1190 {
1192 Relation relation;
1193 TupleDesc tupleDesc;
1196 AttrNumber parent_attno;
1205 /* Permanent rels cannot inherit from temporary ones */
1212 /*
1213 * We should have an UNDER permission flag for this, but for now,
1214 * demand that creator of a child table own the parent.
1215 */
1220 /*
1221 * Reject duplications in the list of parents.
1222 */
1232 parentsWithOids++;
1237 /*
1238 * newattno[] will contain the child-table attribute numbers for the
1239 * attributes of this parent table. (They are not the same for
1240 * parents after the first one, nor if we have dropped columns.)
1241 */
1246 parent_attno++)
1247 {
1253 /*
1254 * Ignore dropped columns in the parent.
1255 */
1257 {
1258 /*
1259 * change_varattnos_of_a_node asserts that this is greater
1260 * than zero, so if anything tries to use it, we should find
1261 * out.
1262 */
1265 }
1267 /*
1268 * Does it conflict with some previously inherited column?
1269 */
1272 {
1273 Oid defTypeId;
1274 int32 deftypmod;
1276 /*
1277 * Yes, try to merge the two column definitions. They must
1278 * have the same type and typmod.
1279 */
1282 attributeName)));
1290 attributeName),
1295 /* Merge of NOT NULL constraints = OR 'em together */
1297 /* Default and other constraints are handled below */
1299 }
1300 else
1301 {
1302 /*
1303 * No, create a new inherited column
1304 */
1317 }
1319 /*
1320 * Copy default if any
1321 */
1323 {
1328 /* Find default in constraint structure */
1332 {
1334 {
1337 }
1338 }
1341 /*
1342 * If default expr could contain any vars, we'd need to fix
1343 * 'em, but it can't; so default is ready to apply to child.
1344 *
1345 * If we already had a default from some prior parent, check
1346 * to see if they are the same. If so, no problem; if not,
1347 * mark the column as having a bogus default. Below, we will
1348 * complain if the bogus default isn't overridden by the child
1349 * schema.
1350 */
1355 {
1358 }
1359 }
1360 }
1362 /*
1363 * Now copy the CHECK constraints of this parent, adjusting attnos
1364 * using the completed newattno[] map. Identically named constraints
1365 * are merged if possible, else we throw error.
1366 */
1368 {
1373 {
1377 /* adjust varattnos of ccbin here */
1381 /* check for duplicate */
1383 {
1384 /* nope, this is a new one */
1395 }
1396 }
1397 }
1401 /*
1402 * Close the parent rel, but keep our AccessShareLock on it until xact
1403 * commit. That will prevent someone else from deleting or ALTERing
1404 * the parent before the child is committed.
1405 */
1407 }
1409 /*
1410 * If we had no inherited attributes, the result schema is just the
1411 * explicitly declared columns. Otherwise, we need to merge the declared
1412 * columns into the inherited schema list.
1413 */
1415 {
1417 {
1422 /*
1423 * Does it conflict with some previously inherited column?
1424 */
1427 {
1429 Oid defTypeId,
1430 newTypeId;
1431 int32 deftypmod,
1432 newtypmod;
1434 /*
1435 * Yes, try to merge the two column definitions. They must
1436 * have the same type and typmod.
1437 */
1440 attributeName)));
1448 attributeName),
1452 /* Mark the column as locally defined */
1454 /* Merge of NOT NULL constraints = OR 'em together */
1456 /* If new def has a default, override previous default */
1458 {
1461 }
1462 }
1463 else
1464 {
1465 /*
1466 * No, attach new column to result schema
1467 */
1469 }
1470 }
1474 /*
1475 * Check that we haven't exceeded the legal # of columns after merging
1476 * in inherited columns.
1477 */
1482 MaxHeapAttributeNumber)));
1483 }
1485 /*
1486 * If we found any conflicting parent default values, check to make sure
1487 * they were overridden by the child.
1488 */
1490 {
1492 {
1501 }
1502 }
1508 }
1511 /*
1512 * MergeCheckConstraint
1513 * Try to merge an inherited CHECK constraint with previous ones
1514 *
1515 * If we inherit identically-named constraints from multiple parents, we must
1516 * merge them, or throw an error if they don't have identical definitions.
1517 *
1518 * constraints is a list of CookedConstraint structs for previous constraints.
1519 *
1520 * Returns TRUE if merged (constraint is a duplicate), or FALSE if it's
1521 * got a so-far-unique name, or throws error if conflict.
1522 */
1523 static bool
1525 {
1529 {
1534 /* Non-matching names never conflict */
1539 {
1540 /* OK to merge */
1543 }
1548 name)));
1549 }
1552 }
1555 /*
1556 * Replace varattno values in an expression tree according to the given
1557 * map array, that is, varattno N is replaced by newattno[N-1]. It is
1558 * caller's responsibility to ensure that the array is long enough to
1559 * define values for all user varattnos present in the tree. System column
1560 * attnos remain unchanged.
1561 *
1562 * Note that the passed node tree is modified in-place!
1563 */
1564 void
1566 {
1567 /* no setup needed, so away we go */
1569 }
1571 static bool
1573 {
1577 {
1582 {
1583 /*
1584 * ??? the following may be a problem when the node is multiply
1585 * referenced though stringToNode() doesn't create such a node
1586 * currently.
1587 */
1590 }
1592 }
1595 }
1597 /*
1598 * Generate a map for change_varattnos_of_a_node from old and new TupleDesc's,
1599 * matching according to column name.
1600 */
1601 AttrNumber *
1603 {
1606 j;
1610 {
1615 {
1618 {
1621 }
1622 }
1623 }
1625 }
1627 /*
1628 * Generate a map for change_varattnos_of_a_node from a TupleDesc and a list
1629 * of ColumnDefs
1630 */
1631 AttrNumber *
1633 {
1639 {
1644 schema);
1645 }
1647 }
1650 /*
1651 * StoreCatalogInheritance
1652 * Updates the system catalogs with proper inheritance information.
1653 *
1654 * supers is a list of the OIDs of the new relation's direct ancestors.
1655 */
1656 static void
1658 {
1659 Relation relation;
1660 int16 seqNumber;
1663 /*
1664 * sanity checks
1665 */
1671 /*
1672 * Store INHERITS information in pg_inherits using direct ancestors only.
1673 * Also enter dependencies on the direct ancestors, and make sure they are
1674 * marked with relhassubclass = true.
1675 *
1676 * (Once upon a time, both direct and indirect ancestors were found here
1677 * and then entered into pg_ipl. Since that catalog doesn't exist
1678 * anymore, there's no need to look for indirect ancestors.)
1679 */
1684 {
1688 seqNumber++;
1689 }
1692 }
1694 /*
1695 * Make catalog entries showing relationId as being an inheritance child
1696 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
1697 */
1698 static void
1701 {
1705 ObjectAddress childobject,
1706 parentobject;
1707 HeapTuple tuple;
1709 /*
1710 * Make the pg_inherits entry
1711 */
1728 /*
1729 * Store a dependency too
1730 */
1740 /*
1741 * Mark the parent as having subclasses.
1742 */
1744 }
1746 /*
1747 * Look for an existing schema entry with the given name.
1748 *
1749 * Returns the index (starting with 1) if attribute already exists in schema,
1750 * 0 if it doesn't.
1751 */
1752 static int
1754 {
1759 {
1765 i++;
1766 }
1768 }
1770 /*
1771 * Update a relation's pg_class.relhassubclass entry to the given value
1772 */
1773 static void
1775 {
1776 Relation relationRelation;
1777 HeapTuple tuple;
1778 Form_pg_class classtuple;
1780 /*
1781 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
1782 *
1783 * If the tuple already has the right relhassubclass setting, we don't
1784 * need to update it, but we still need to issue an SI inval message.
1785 */
1795 {
1799 /* keep the catalog indexes up to date */
1801 }
1802 else
1803 {
1804 /* no need to change tuple, but force relcache rebuild anyway */
1806 }
1810 }
1813 /*
1814 * renameatt - changes the name of a attribute in a relation
1815 *
1816 * Attname attribute is changed in attribute catalog.
1817 * No record of the previous attname is kept (correct?).
1818 *
1819 * get proper relrelation from relation catalog (if not arg)
1820 * scan attribute catalog
1821 * for name conflict (within rel)
1822 * for original attribute (if not arg)
1823 * modify attname in attribute tuple
1824 * insert modified attribute in attribute catalog
1825 * delete original attribute from attribute catalog
1826 */
1827 void
1833 {
1834 Relation targetrelation;
1835 Relation attrelation;
1836 HeapTuple atttup;
1837 Form_pg_attribute attform;
1842 /*
1843 * Grab an exclusive lock on the target table, which we will NOT release
1844 * until end of transaction.
1845 */
1848 /*
1849 * permissions checking. this would normally be done in utility.c, but
1850 * this particular routine is recursive.
1851 *
1852 * normally, only the owner of a class can change its schema.
1853 */
1863 /*
1864 * if the 'recurse' flag is set then we are supposed to rename this
1865 * attribute in all classes that inherit from 'relname' (as well as in
1866 * 'relname').
1867 *
1868 * any permissions or problems with duplicate attributes will cause the
1869 * whole transaction to abort, which is what we want -- all or nothing.
1870 */
1872 {
1878 /*
1879 * find_all_inheritors does the recursive search of the inheritance
1880 * hierarchy, so all we have to do is process all of the relids in the
1881 * list that it returns.
1882 */
1884 {
1889 /* note we need not recurse again */
1891 }
1892 }
1893 else
1894 {
1895 /*
1896 * If we are told not to recurse, there had better not be any child
1897 * tables; else the rename would put them out of step.
1898 */
1904 oldattname)));
1905 }
1914 oldattname)));
1922 oldattname)));
1924 /*
1925 * if the attribute is inherited, forbid the renaming, unless we are
1926 * already inside a recursive rename.
1927 */
1932 oldattname)));
1934 /* should not already exist */
1935 /* this test is deliberately not attisdropped-aware */
1949 /* keep system catalog indexes current */
1954 /*
1955 * Update column names of indexes that refer to the column being renamed.
1956 */
1960 {
1962 HeapTuple indextup;
1963 Form_pg_index indexform;
1966 /*
1967 * Scan through index columns to see if there's any simple index
1968 * entries for this attribute. We ignore expressional entries.
1969 */
1978 {
1982 /*
1983 * Found one, rename it.
1984 */
1992 /*
1993 * Update the (copied) attribute tuple.
1994 */
1996 newattname);
2000 /* keep system catalog indexes current */
2004 }
2007 }
2014 }
2017 /*
2018 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW RENAME
2019 *
2020 * Caller has already done permissions checks.
2021 */
2022 void
2024 {
2025 Relation targetrelation;
2026 Oid namespaceId;
2029 /*
2030 * Grab an exclusive lock on the target table, index, sequence or view,
2031 * which we will NOT release until end of transaction.
2032 */
2038 /*
2039 * For compatibility with prior releases, we don't complain if ALTER TABLE
2040 * or ALTER INDEX is used to rename a sequence or view.
2041 */
2054 /*
2055 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
2056 * TYPE for that.
2057 */
2065 /* Do the work */
2068 /*
2069 * Close rel, but keep exclusive lock!
2070 */
2072 }
2074 /*
2075 * RenameRelationInternal - change the name of a relation
2076 *
2077 * XXX - When renaming sequences, we don't bother to modify the
2078 * sequence name that is stored within the sequence itself
2079 * (this would cause problems with MVCC). In the future,
2080 * the sequence name should probably be removed from the
2081 * sequence, AFAIK there's no need for it to be there.
2082 */
2083 void
2085 {
2086 Relation targetrelation;
2088 HeapTuple reltup;
2089 Form_pg_class relform;
2091 /*
2092 * Grab an exclusive lock on the target table, index, sequence or view,
2093 * which we will NOT release until end of transaction.
2094 */
2097 /*
2098 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
2099 */
2113 newrelname)));
2115 /*
2116 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
2117 * because it's a copy...)
2118 */
2123 /* keep the system catalog indexes current */
2129 /*
2130 * Also rename the associated type, if any.
2131 */
2136 /*
2137 * Also rename the associated constraint, if any.
2138 */
2140 {
2145 }
2147 /*
2148 * Close rel, but keep exclusive lock!
2149 */
2151 }
2153 /*
2154 * Disallow ALTER TABLE (and similar commands) when the current backend has
2155 * any open reference to the target table besides the one just acquired by
2156 * the calling command; this implies there's an open cursor or active plan.
2157 * We need this check because our AccessExclusiveLock doesn't protect us
2158 * against stomping on our own foot, only other people's feet!
2159 *
2160 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
2161 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
2162 * possibly be relaxed to only error out for certain types of alterations.
2163 * But the use-case for allowing any of these things is not obvious, so we
2164 * won't work hard at it for now.
2165 *
2166 * We also reject these commands if there are any pending AFTER trigger events
2167 * for the rel. This is certainly necessary for the rewriting variants of
2168 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
2169 * events would try to fetch the wrong tuples. It might be overly cautious
2170 * in other cases, but again it seems better to err on the side of paranoia.
2171 *
2172 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
2173 * we are worried about active indexscans on the index. The trigger-event
2174 * check can be skipped, since we are doing no damage to the parent table.
2175 *
2176 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
2177 */
2178 void
2180 {
2187 /* translator: first %s is a SQL command, eg ALTER TABLE */
2196 /* translator: first %s is a SQL command, eg ALTER TABLE */
2200 }
2202 /*
2203 * AlterTable
2204 * Execute ALTER TABLE, which can be a list of subcommands
2205 *
2206 * ALTER TABLE is performed in three phases:
2207 * 1. Examine subcommands and perform pre-transformation checking.
2208 * 2. Update system catalogs.
2209 * 3. Scan table(s) to check new constraints, and optionally recopy
2210 * the data into new table(s).
2211 * Phase 3 is not performed unless one or more of the subcommands requires
2212 * it. The intention of this design is to allow multiple independent
2213 * updates of the table schema to be performed with only one pass over the
2214 * data.
2215 *
2216 * ATPrepCmd performs phase 1. A "work queue" entry is created for
2217 * each table to be affected (there may be multiple affected tables if the
2218 * commands traverse a table inheritance hierarchy). Also we do preliminary
2219 * validation of the subcommands, including parse transformation of those
2220 * expressions that need to be evaluated with respect to the old table
2221 * schema.
2222 *
2223 * ATRewriteCatalogs performs phase 2 for each affected table. (Note that
2224 * phases 2 and 3 normally do no explicit recursion, since phase 1 already
2225 * did it --- although some subcommands have to recurse in phase 2 instead.)
2226 * Certain subcommands need to be performed before others to avoid
2227 * unnecessary conflicts; for example, DROP COLUMN should come before
2228 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
2229 * lists, one for each logical "pass" of phase 2.
2230 *
2231 * ATRewriteTables performs phase 3 for those tables that need it.
2232 *
2233 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
2234 * the whole operation; we don't have to do anything special to clean up.
2235 */
2236 void
2238 {
2243 /* Check relation type against type specified in the ALTER command */
2245 {
2248 /*
2249 * For mostly-historical reasons, we allow ALTER TABLE to apply to
2250 * all relation types.
2251 */
2280 }
2283 }
2285 /*
2286 * AlterTableInternal
2287 *
2288 * ALTER TABLE with target specified by OID
2289 *
2290 * We do not reject if the relation is already open, because it's quite
2291 * likely that one or more layers of caller have it open. That means it
2292 * is unsafe to use this entry point for alterations that could break
2293 * existing query plans. On the assumption it's not used for such, we
2294 * don't have to reject pending AFTER triggers, either.
2295 */
2296 void
2298 {
2302 }
2304 static void
2306 {
2310 /* Phase 1: preliminary examination of commands, create work queue */
2312 {
2316 }
2318 /* Close the relation, but keep lock until commit */
2321 /* Phase 2: update system catalogs */
2324 /* Phase 3: scan/rewrite tables as needed */
2326 }
2328 /*
2329 * ATPrepCmd
2330 *
2331 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
2332 * recursion and permission checks.
2333 *
2334 * Caller must have acquired AccessExclusiveLock on relation already.
2335 * This lock should be held until commit.
2336 */
2337 static void
2340 {
2344 /* Find or create work queue entry for this table */
2347 /*
2348 * Copy the original subcommand for each table. This avoids conflicts
2349 * when different child tables need to make different parse
2350 * transformations (for example, the same column may have different column
2351 * numbers in different children).
2352 */
2355 /*
2356 * Do permissions checking, recursion to child tables if needed, and any
2357 * additional phase-1 processing needed.
2358 */
2360 {
2363 /* Performs own recursion */
2368 * VIEW */
2370 /* Performs own recursion */
2376 /*
2377 * We allow defaults on views so that INSERT into a view can have
2378 * default-ish behavior. This works because the rewriter
2379 * substitutes default values into INSERTs before it expands
2380 * rules.
2381 */
2384 /* No command-specific prep needed */
2390 /* No command-specific prep needed */
2396 /* No command-specific prep needed */
2401 /* Performs own permission checks */
2408 /* No command-specific prep needed */
2413 /* Recursion occurs during execution phase */
2414 /* No command-specific prep needed except saving recurse flag */
2421 /* This command never recurses */
2422 /* No command-specific prep needed */
2427 /* Recursion occurs during execution phase */
2428 /* No command-specific prep needed except saving recurse flag */
2435 /* Recursion occurs during execution phase */
2436 /* No command-specific prep needed except saving recurse flag */
2443 /* Performs own recursion */
2448 /* This command never recurses */
2449 /* No command-specific prep needed */
2455 /* These commands never recurse */
2456 /* No command-specific prep needed */
2461 /* Performs own recursion */
2468 /* Performs own recursion */
2470 {
2477 }
2482 /* This command never recurses */
2489 /* This command never recurses */
2490 /* No command-specific prep needed */
2508 /* These commands never recurse */
2509 /* No command-specific prep needed */
2517 }
2519 /* Add the subcommand to the appropriate list for phase 2 */
2521 }
2523 /*
2524 * ATRewriteCatalogs
2525 *
2526 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
2527 * dispatched in a "safe" execution order (designed to avoid unnecessary
2528 * conflicts).
2529 */
2530 static void
2532 {
2536 /*
2537 * We process all the tables "in parallel", one pass at a time. This is
2538 * needed because we may have to propagate work from one table to another
2539 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
2540 * re-adding of the foreign key constraint to the other table). Work can
2541 * only be propagated into later passes, however.
2542 */
2544 {
2545 /* Go through each table that needs to be processed */
2547 {
2550 Relation rel;
2556 /*
2557 * Exclusive lock was obtained by phase 1, needn't get it again
2558 */
2564 /*
2565 * After the ALTER TYPE pass, do cleanup work (this is not done in
2566 * ATExecAlterColumnType since it should be done only once if
2567 * multiple columns of a table are altered).
2568 */
2573 }
2574 }
2576 /*
2577 * Check to see if a toast table must be added, if we executed any
2578 * subcommands that might have added a column or changed column storage.
2579 */
2581 {
2590 }
2591 }
2593 /*
2594 * ATExecCmd: dispatch a subcommand to appropriate execution routine
2595 */
2596 static void
2599 {
2601 {
2604 * VIEW */
2663 /* Use the ADD COLUMN code, unless prep decided to do nothing */
2669 /*
2670 * Nothing to do here; we'll have generated a DropColumn
2671 * subcommand to do the real work
2672 */
2676 /*
2677 * Nothing to do here; Phase 3 does the work
2678 */
2722 RULE_FIRES_ON_ORIGIN);
2726 RULE_FIRES_ALWAYS);
2730 RULE_FIRES_ON_REPLICA);
2734 RULE_DISABLED);
2747 }
2749 /*
2750 * Bump the command counter to ensure the next subcommand in the sequence
2751 * can see the changes so far
2752 */
2754 }
2756 /*
2757 * ATRewriteTables: ALTER TABLE phase 3
2758 */
2759 static void
2761 {
2764 /* Go through each table that needs to be checked or rewritten */
2766 {
2769 /*
2770 * We only need to rewrite the table if at least one column needs to
2771 * be recomputed, or we are adding/removing the OID column.
2772 */
2774 {
2775 /* Build a temporary relation and copy data */
2776 Oid OIDNewHeap;
2778 Oid NewTableSpace;
2779 Relation OldHeap;
2780 ObjectAddress object;
2784 /*
2785 * We can never allow rewriting of shared or nailed-in-cache
2786 * relations, because we can't support changing their relfilenode
2787 * values.
2788 */
2795 /*
2796 * Don't allow rewrite on temp tables of other backends ... their
2797 * local buffer manager is not going to cope.
2798 */
2804 /*
2805 * Select destination tablespace (same as original unless user
2806 * requested a change)
2807 */
2810 else
2815 /*
2816 * Create the new heap, using a temporary name in the same
2817 * namespace as the existing table. NOTE: there is some risk of
2818 * collision with user relnames. Working around this seems more
2819 * trouble than it's worth; in particular, we can't create the new
2820 * heap in a different namespace from the old, or we will have
2821 * problems with the TEMP status of temp tables.
2822 */
2828 /*
2829 * Copy the heap data into the new table with the desired
2830 * modifications, and test the current data within the table
2831 * against new constraints generated by ALTER TABLE commands.
2832 */
2835 /*
2836 * Swap the physical files of the old and new heaps. Since we are
2837 * generating a new heap, we can use RecentXmin for the table's
2838 * new relfrozenxid because we rewrote all the tuples on
2839 * ATRewriteTable, so no older Xid remains on the table.
2840 */
2845 /* Destroy new heap with old filenode */
2850 /*
2851 * The new relation is local to our transaction and we know
2852 * nothing depends on it, so DROP_RESTRICT should be OK.
2853 */
2855 /* performDeletion does CommandCounterIncrement at end */
2857 /*
2858 * Rebuild each index on the relation (but not the toast table,
2859 * which is all-new anyway). We do not need
2860 * CommandCounterIncrement() because reindex_relation does it.
2861 */
2863 }
2864 else
2865 {
2866 /*
2867 * Test the current data within the table against new constraints
2868 * generated by ALTER TABLE commands, but don't rebuild data.
2869 */
2873 /*
2874 * If we had SET TABLESPACE but no reason to reconstruct tuples,
2875 * just do a block-by-block copy.
2876 */
2879 }
2880 }
2882 /*
2883 * Foreign key constraints are checked in a final pass, since (a) it's
2884 * generally best to examine each one separately, and (b) it's at least
2885 * theoretically possible that we have changed both relations of the
2886 * foreign key, and we'd better have finished both rewrites before we try
2887 * to read the tables.
2888 */
2890 {
2896 {
2900 {
2902 Relation refrel;
2905 {
2906 /* Long since locked, no need for another */
2908 }
2916 }
2917 }
2921 }
2922 }
2924 /*
2925 * ATRewriteTable: scan or rewrite one table
2926 *
2927 * OIDNewHeap is InvalidOid if we don't need to rewrite
2928 */
2929 static void
2931 {
2932 Relation oldrel;
2933 Relation newrel;
2934 TupleDesc oldTupDesc;
2935 TupleDesc newTupDesc;
2942 /*
2943 * Open the relation(s). We have surely already locked the existing
2944 * table.
2945 */
2952 else
2955 /*
2956 * If we need to rewrite the table, the operation has to be propagated to
2957 * tables that use this table's rowtype as a column type.
2958 *
2959 * (Eventually this will probably become true for scans as well, but at
2960 * the moment a composite type does not enforce any constraints, so it's
2961 * not necessary/appropriate to enforce them just during ALTER.)
2962 */
2966 NULL);
2968 /*
2969 * Generate the constraint and default execution states
2970 */
2974 /* Build the needed expression execution states */
2976 {
2980 {
2987 /* Nothing to do here */
2992 }
2993 }
2996 {
3000 }
3004 {
3005 /*
3006 * If we are rebuilding the tuples OR if we added any new NOT NULL
3007 * constraints, check all not-null constraints. This is a bit of
3008 * overkill but it minimizes risk of bugs, and heap_attisnull is a
3009 * pretty cheap test anyway.
3010 */
3012 {
3016 }
3019 }
3022 {
3028 HeapScanDesc scan;
3029 HeapTuple tuple;
3030 MemoryContext oldCxt;
3036 /*
3037 * Make tuple slots for old and new tuples. Note that even when the
3038 * tuples are the same, the tupDescs might not be (consider ADD COLUMN
3039 * without a default).
3040 */
3044 /* Preallocate values/isnull arrays */
3051 /*
3052 * Any attributes that are dropped according to the new tuple
3053 * descriptor can be set to NULL. We precompute the list of dropped
3054 * attributes to avoid needing to do so in the per-tuple loop.
3055 */
3057 {
3060 }
3062 /*
3063 * Scan through the rows, generating a new row if needed and then
3064 * checking all the constraints.
3065 */
3068 /*
3069 * Switch to per-tuple memory context and reset it for each tuple
3070 * produced, so we don't leak memory.
3071 */
3075 {
3077 {
3080 /* Extract data from old tuple */
3085 /* Set dropped attributes to null in new tuple */
3089 /*
3090 * Process supplied expressions to replace selected columns.
3091 * Expression inputs come from the old tuple.
3092 */
3097 {
3101 econtext,
3103 NULL);
3104 }
3106 /*
3107 * Form the new tuple. Note that we don't explicitly pfree it,
3108 * since the per-tuple memory context will be reset shortly.
3109 */
3112 /* Preserve OID, if any */
3115 }
3117 /* Now check any constraints on the possibly-changed tuple */
3122 {
3130 }
3133 {
3137 {
3146 /* Nothing to do here */
3151 }
3152 }
3154 /* Write the tuple out to the new relation */
3161 }
3168 }
3175 }
3177 /*
3178 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
3179 */
3182 {
3188 {
3192 }
3194 /*
3195 * Not there, so add it. Note that we make a copy of the relation's
3196 * existing descriptor before anything interesting can happen to it.
3197 */
3206 }
3208 /*
3209 * ATSimplePermissions
3210 *
3211 * - Ensure that it is a relation (or possibly a view)
3212 * - Ensure this user is the owner
3213 * - Ensure that it is not a system table
3214 */
3215 static void
3217 {
3219 {
3221 {
3227 }
3228 else
3233 }
3235 /* Permissions checks */
3245 }
3247 /*
3248 * ATSimplePermissionsRelationOrIndex
3249 *
3250 * - Ensure that it is a relation or an index
3251 * - Ensure this user is the owner
3252 * - Ensure that it is not a system table
3253 */
3254 static void
3256 {
3264 /* Permissions checks */
3274 }
3276 /*
3277 * ATSimpleRecursion
3278 *
3279 * Simple table recursion sufficient for most ALTER TABLE operations.
3280 * All direct and indirect children are processed in an unspecified order.
3281 * Note that if a child inherits from the original table via multiple
3282 * inheritance paths, it will be visited just once.
3283 */
3284 static void
3287 {
3288 /*
3289 * Propagate to children if desired. Non-table relations never have
3290 * children, so no need to search in that case.
3291 */
3293 {
3300 /*
3301 * find_all_inheritors does the recursive search of the inheritance
3302 * hierarchy, so all we have to do is process all of the relids in the
3303 * list that it returns.
3304 */
3306 {
3308 Relation childrel;
3312 /* find_all_inheritors already got lock */
3317 }
3318 }
3319 }
3321 /*
3322 * ATOneLevelRecursion
3323 *
3324 * Here, we visit only direct inheritance children. It is expected that
3325 * the command's prep routine will recurse again to find indirect children.
3326 * When using this technique, a multiply-inheriting child will be visited
3327 * multiple times.
3328 */
3329 static void
3332 {
3340 {
3342 Relation childrel;
3344 /* find_inheritance_children already got lock */
3349 }
3350 }
3353 /*
3354 * find_composite_type_dependencies
3355 *
3356 * Check to see if a composite type is being used as a column in some
3357 * other table (possibly nested several levels deep in composite types!).
3358 * Eventually, we'd like to propagate the check or rewrite operation
3359 * into other such tables, but for now, just error out if we find any.
3360 *
3361 * Caller should provide either a table name or a type name (not both) to
3362 * report in the error message, if any.
3363 *
3364 * We assume that functions and views depending on the type are not reasons
3365 * to reject the ALTER. (How safe is this really?)
3366 */
3367 void
3371 {
3372 Relation depRel;
3374 SysScanDesc depScan;
3375 HeapTuple depTup;
3376 Oid arrayOid;
3378 /*
3379 * We scan pg_depend to find those things that depend on the rowtype. (We
3380 * assume we can ignore refobjsubid for a rowtype.)
3381 */
3385 Anum_pg_depend_refclassid,
3389 Anum_pg_depend_refobjid,
3397 {
3399 Relation rel;
3400 Form_pg_attribute att;
3402 /* Ignore dependees that aren't user columns of relations */
3403 /* (we assume system columns are never of rowtypes) */
3412 {
3417 origTblName,
3420 else
3424 origTypeName,
3427 }
3429 {
3430 /*
3431 * A view or composite type itself isn't a problem, but we must
3432 * recursively check for indirect dependencies via its rowtype.
3433 */
3436 }
3439 }
3445 /*
3446 * If there's an array type for the rowtype, must check for uses of it,
3447 * too.
3448 */
3452 }
3455 /*
3456 * ALTER TABLE ADD COLUMN
3457 *
3458 * Adds an additional attribute to a relation making the assumption that
3459 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
3460 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
3461 * AlterTableCmd's.
3462 */
3463 static void
3466 {
3467 /*
3468 * Recurse to add the column to child classes, if requested.
3469 *
3470 * We must recurse one level at a time, so that multiply-inheriting
3471 * children are visited the right number of times and end up with the
3472 * right attinhcount.
3473 */
3475 {
3479 /* Child should see column as singly inherited */
3484 }
3485 else
3486 {
3487 /*
3488 * If we are told not to recurse, there had better not be any child
3489 * tables; else the addition would put them out of step.
3490 */
3495 }
3496 }
3498 static void
3501 {
3503 Relation pgclass,
3504 attrdesc;
3505 HeapTuple reltup;
3506 FormData_pg_attribute attribute;
3509 HeapTuple typeTuple;
3510 Oid typeOid;
3511 int32 typmod;
3512 Form_pg_type tform;
3517 /*
3518 * Are we adding the column to a recursion child? If so, check whether to
3519 * merge with an existing definition for the column.
3520 */
3522 {
3523 HeapTuple tuple;
3525 /* Does child already have a column by this name? */
3528 {
3530 Oid ctypeId;
3531 int32 ctypmod;
3533 /* Child column must match by type */
3542 /* If it's OID, child column must actually be OID */
3549 /* Bump the existing child att's inhcount */
3556 /* Inform the user about the merge */
3563 }
3564 }
3575 /*
3576 * this test is deliberately not attisdropped-aware, since if one tries to
3577 * add a column matching a dropped column name, it's gonna fail anyway.
3578 */
3588 /* Determine the new attribute's number */
3591 else
3592 {
3598 MaxHeapAttributeNumber)));
3599 }
3605 /* make sure datatype is legal for a column */
3608 /* construct new attribute's pg_attribute entry */
3626 /* attribute.attacl is handled by InsertPgAttributeTuple */
3634 /*
3635 * Update pg_class tuple as appropriate
3636 */
3639 else
3644 /* keep catalog indexes current */
3651 /* Make the attribute's catalog entry visible */
3654 /*
3655 * Store the DEFAULT, if any, in the catalogs
3656 */
3658 {
3665 /*
3666 * This function is intended for CREATE TABLE, so it processes a
3667 * _list_ of defaults, but we just do one.
3668 */
3671 /* Make the additional catalog changes visible */
3673 }
3675 /*
3676 * Tell Phase 3 to fill in the default expression, if there is one.
3677 *
3678 * If there is no default, Phase 3 doesn't have to do anything, because
3679 * that effectively means that the default is NULL. The heap tuple access
3680 * routines always check for attnum > # of attributes in tuple, and return
3681 * NULL if so, so without any modification of the tuple data we will get
3682 * the effect of NULL values in the new column.
3683 *
3684 * An exception occurs when the new column is of a domain type: the domain
3685 * might have a NOT NULL constraint, or a check constraint that indirectly
3686 * rejects nulls. If there are any domain constraints then we construct
3687 * an explicit NULL default value that will be passed through
3688 * CoerceToDomain processing. (This is a tad inefficient, since it causes
3689 * rewriting the table which we really don't have to do, but the present
3690 * design of domain processing doesn't offer any simple way of checking
3691 * the constraints more directly.)
3692 *
3693 * Note: we use build_column_default, and not just the cooked default
3694 * returned by AddRelationNewConstraints, so that the right thing happens
3695 * when a datatype's default applies.
3696 *
3697 * We skip this step completely for views. For a view, we can only get
3698 * here from CREATE OR REPLACE VIEW, which historically doesn't set up
3699 * defaults, not even for domain-typed columns. And in any case we
3700 * mustn't invoke Phase 3 on a view, since it has no storage.
3701 */
3703 {
3707 {
3708 Oid baseTypeId;
3709 int32 baseTypeMod;
3716 baseTypeId,
3717 typeOid,
3718 typmod,
3719 COERCION_ASSIGNMENT,
3720 COERCE_IMPLICIT_CAST,
3724 }
3727 {
3735 }
3737 /*
3738 * If the new column is NOT NULL, tell Phase 3 it needs to test that.
3739 * (Note we don't do this for an OID column. OID will be marked not
3740 * null, but since it's filled specially, there's no need to test
3741 * anything.)
3742 */
3744 }
3746 /*
3747 * If we are adding an OID column, we have to tell Phase 3 to rewrite the
3748 * table to fix that.
3749 */
3753 /*
3754 * Add needed dependency entries for the new column.
3755 */
3757 }
3759 /*
3760 * Install a column's dependency on its datatype.
3761 */
3762 static void
3764 {
3765 ObjectAddress myself,
3766 referenced;
3775 }
3777 /*
3778 * ALTER TABLE SET WITH OIDS
3779 *
3780 * Basically this is an ADD COLUMN for the special OID column. We have
3781 * to cons up a ColumnDef node because the ADD COLUMN code needs one.
3782 */
3783 static void
3785 {
3786 /* If we're recursing to a child table, the ColumnDef is already set up */
3788 {
3797 }
3799 }
3801 /*
3802 * ALTER TABLE ALTER COLUMN DROP NOT NULL
3803 */
3804 static void
3806 {
3807 HeapTuple tuple;
3808 AttrNumber attnum;
3809 Relation attr_rel;
3813 /*
3814 * lookup the attribute
3815 */
3828 /* Prevent them from altering a system attribute */
3833 colName)));
3835 /*
3836 * Check that the attribute is not in a primary key
3837 */
3839 /* Loop over all indexes on the relation */
3843 {
3845 HeapTuple indexTuple;
3846 Form_pg_index indexStruct;
3856 /* If the index is not a primary key, skip the check */
3858 {
3859 /*
3860 * Loop over each attribute in the primary key and see if it
3861 * matches the to-be-altered attribute
3862 */
3864 {
3869 colName)));
3870 }
3871 }
3874 }
3878 /*
3879 * Okay, actually perform the catalog change ... if needed
3880 */
3882 {
3887 /* keep the system catalog indexes current */
3889 }
3892 }
3894 /*
3895 * ALTER TABLE ALTER COLUMN SET NOT NULL
3896 */
3897 static void
3900 {
3901 HeapTuple tuple;
3902 AttrNumber attnum;
3903 Relation attr_rel;
3905 /*
3906 * lookup the attribute
3907 */
3920 /* Prevent them from altering a system attribute */
3925 colName)));
3927 /*
3928 * Okay, actually perform the catalog change ... if needed
3929 */
3931 {
3936 /* keep the system catalog indexes current */
3939 /* Tell Phase 3 it needs to test the constraint */
3941 }
3944 }
3946 /*
3947 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
3948 */
3949 static void
3952 {
3953 AttrNumber attnum;
3955 /*
3956 * get the number of the attribute
3957 */
3965 /* Prevent them from altering a system attribute */
3970 colName)));
3972 /*
3973 * Remove any old default for the column. We use RESTRICT here for
3974 * safety, but at present we do not expect anything to depend on the
3975 * default.
3976 */
3980 {
3981 /* SET DEFAULT */
3988 /*
3989 * This function is intended for CREATE TABLE, so it processes a
3990 * _list_ of defaults, but we just do one.
3991 */
3993 }
3994 }
3996 /*
3997 * ALTER TABLE ALTER COLUMN SET STATISTICS
3998 */
3999 static void
4001 {
4002 /*
4003 * We do our own permission checking because (a) we want to allow SET
4004 * STATISTICS on indexes (for expressional index columns), and (b) we want
4005 * to allow SET STATISTICS on system catalogs without requiring
4006 * allowSystemTableMods to be turned on.
4007 */
4015 /* Permissions checks */
4019 }
4021 static void
4023 {
4025 Relation attrelation;
4026 HeapTuple tuple;
4027 Form_pg_attribute attrtuple;
4032 /*
4033 * Limit target to a sane range
4034 */
4036 {
4040 newtarget)));
4041 }
4043 {
4048 newtarget)));
4049 }
4066 colName)));
4072 /* keep system catalog indexes current */
4078 }
4080 /*
4081 * ALTER TABLE ALTER COLUMN SET STORAGE
4082 */
4083 static void
4085 {
4088 Relation attrelation;
4089 HeapTuple tuple;
4090 Form_pg_attribute attrtuple;
4103 else
4104 {
4108 storagemode)));
4110 }
4127 colName)));
4129 /*
4130 * safety check: do not allow toasted storage modes unless column datatype
4131 * is TOAST-aware.
4132 */
4135 else
4143 /* keep system catalog indexes current */
4149 }
4152 /*
4153 * ALTER TABLE DROP COLUMN
4154 *
4155 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
4156 * because we have to decide at runtime whether to recurse or not depending
4157 * on whether attinhcount goes to zero or not. (We can't check this in a
4158 * static pre-pass because it won't handle multiple inheritance situations
4159 * correctly.)
4160 */
4161 static void
4163 DropBehavior behavior,
4165 {
4166 HeapTuple tuple;
4167 Form_pg_attribute targetatt;
4168 AttrNumber attnum;
4170 ObjectAddress object;
4172 /* At top level, permission check was done in ATPrepCmd, else do it */
4176 /*
4177 * get the number of the attribute
4178 */
4189 /* Can't drop a system attribute, except OID */
4194 colName)));
4196 /* Don't drop inherited columns */
4201 colName)));
4205 /*
4206 * Propagate to children as appropriate. Unlike most other ALTER
4207 * routines, we have to do this one level of recursion at a time; we can't
4208 * use find_all_inheritors to do it in one pass.
4209 */
4211 AccessExclusiveLock);
4214 {
4215 Relation attr_rel;
4220 {
4222 Relation childrel;
4223 Form_pg_attribute childatt;
4225 /* find_inheritance_children already got lock */
4240 {
4241 /*
4242 * If the child column has other definition sources, just
4243 * decrement its inheritance count; if not, recurse to delete
4244 * it.
4245 */
4247 {
4248 /* Time to delete this child column, too */
4251 }
4252 else
4253 {
4254 /* Child column must survive my deletion */
4259 /* keep the system catalog indexes current */
4262 /* Make update visible */
4264 }
4265 }
4266 else
4267 {
4268 /*
4269 * If we were told to drop ONLY in this table (no recursion),
4270 * we need to mark the inheritors' attributes as locally
4271 * defined rather than inherited.
4272 */
4278 /* keep the system catalog indexes current */
4281 /* Make update visible */
4283 }
4288 }
4290 }
4292 /*
4293 * Perform the actual column deletion
4294 */
4301 /*
4302 * If we dropped the OID column, must adjust pg_class.relhasoids and tell
4303 * Phase 3 to physically get rid of the column.
4304 */
4306 {
4307 Relation class_rel;
4308 Form_pg_class tuple_class;
4324 /* Keep the catalog indexes up to date */
4329 /* Find or create work queue entry for this table */
4332 /* Tell Phase 3 to physically remove the OID column */
4334 }
4335 }
4337 /*
4338 * ALTER TABLE ADD INDEX
4339 *
4340 * There is no such command in the grammar, but parse_utilcmd.c converts
4341 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
4342 * us schedule creation of the index at the appropriate time during ALTER.
4343 */
4344 static void
4347 {
4354 /* suppress schema rights check when rebuilding existing index */
4356 /* skip index build if phase 3 will have to rewrite table anyway */
4358 /* suppress notices when rebuilding existing index */
4361 /* The IndexStmt has already been through transformIndexStmt */
4375 check_rights,
4376 skip_build,
4377 quiet,
4379 }
4381 /*
4382 * ALTER TABLE ADD CONSTRAINT
4383 */
4384 static void
4387 {
4389 {
4391 {
4394 /*
4395 * Currently, we only expect to see CONSTR_CHECK nodes
4396 * arriving here (see the preprocessing done in
4397 * parse_utilcmd.c). Use a switch anyway to make it easier to
4398 * add more code later.
4399 */
4401 {
4409 }
4411 }
4413 {
4416 /*
4417 * Note that we currently never recurse for FK constraints, so
4418 * the "recurse" flag is silently ignored.
4419 *
4420 * Assign or validate constraint name
4421 */
4423 {
4433 }
4434 else
4440 NIL);
4445 }
4449 }
4450 }
4452 /*
4453 * Add a check constraint to a single table and its children
4454 *
4455 * Subroutine for ATExecAddConstraint.
4456 *
4457 * We must recurse to child tables during execution, rather than using
4458 * ALTER TABLE's normal prep-time recursion. The reason is that all the
4459 * constraints *must* be given the same name, else they won't be seen as
4460 * related later. If the user didn't explicitly specify a name, then
4461 * AddRelationNewConstraints would normally assign different names to the
4462 * child constraints. To fix that, we must capture the name assigned at
4463 * the parent table and pass that down.
4464 */
4465 static void
4468 {
4474 /* At top level, permission check was done in ATPrepCmd, else do it */
4478 /*
4479 * Call AddRelationNewConstraints to do the work, making sure it works on
4480 * a copy of the Constraint so transformExpr can't modify the original. It
4481 * returns a list of cooked constraints.
4482 *
4483 * If the constraint ends up getting merged with a pre-existing one, it's
4484 * omitted from the returned list, which is what we want: we do not need
4485 * to do any validation work. That can only happen at child tables,
4486 * though, since we disallow merging at the top level.
4487 */
4492 /* Add each constraint to Phase 3's queue */
4494 {
4501 /* ExecQual wants implicit-AND format */
4506 /* Save the actually assigned name if it was defaulted */
4509 }
4511 /* At this point we must have a locked-down name to use */
4514 /* Advance command counter in case same table is visited multiple times */
4517 /*
4518 * Propagate to children as appropriate. Unlike most other ALTER
4519 * routines, we have to do this one level of recursion at a time; we can't
4520 * use find_all_inheritors to do it in one pass.
4521 */
4523 AccessExclusiveLock);
4525 /*
4526 * If we are told not to recurse, there had better not be any child
4527 * tables; else the addition would put them out of step.
4528 */
4535 {
4537 Relation childrel;
4540 /* find_inheritance_children already got lock */
4544 /* Find or create work queue entry for this table */
4547 /* Recurse to child */
4552 }
4553 }
4555 /*
4556 * Add a foreign-key constraint to a single table
4557 *
4558 * Subroutine for ATExecAddConstraint. Must already hold exclusive
4559 * lock on the rel, and have done appropriate validity checks for it.
4560 * We do permissions checks here, however.
4561 */
4562 static void
4565 {
4566 Relation pkrel;
4577 numpks;
4578 Oid indexOid;
4579 Oid constrOid;
4581 /*
4582 * Grab an exclusive lock on the pk table, so that someone doesn't delete
4583 * rows out from under us. (Although a lesser lock would do for that
4584 * purpose, we'll need exclusive lock anyway to add triggers to the pk
4585 * table; trying to start with a lesser lock will just create a risk of
4586 * deadlock.)
4587 */
4590 /*
4591 * Validity checks (permission checks wait till we have the column
4592 * numbers)
4593 */
4606 /*
4607 * Disallow reference from permanent table to temp table or vice versa.
4608 * (The ban on perm->temp is for fairly obvious reasons. The ban on
4609 * temp->perm is because other backends might need to run the RI triggers
4610 * on the perm table, but they can't reliably see tuples the owning
4611 * backend has created in the temp table, because non-shared buffers are
4612 * used for temp tables.)
4613 */
4615 {
4620 }
4621 else
4622 {
4627 }
4629 /*
4630 * Look up the referencing attributes to make sure they exist, and record
4631 * their attnums and type OIDs.
4632 */
4646 /*
4647 * If the attribute list for the referenced table was omitted, lookup the
4648 * definition of the primary key and use it. Otherwise, validate the
4649 * supplied attribute list. In either case, discover the index OID and
4650 * index opclasses, and the attnums and type OIDs of the attributes.
4651 */
4653 {
4657 opclasses);
4658 }
4659 else
4660 {
4664 /* Look for an index matching the column list */
4666 opclasses);
4667 }
4669 /*
4670 * Now we can check permissions.
4671 */
4675 /*
4676 * Look up the equality operators to use in the constraint.
4677 *
4678 * Note that we have to be careful about the difference between the actual
4679 * PK column type and the opclass' declared input type, which might be
4680 * only binary-compatible with it. The declared opcintype is the right
4681 * thing to probe pg_amop with.
4682 */
4689 {
4692 Oid fktyped;
4693 HeapTuple cla_ht;
4694 Form_pg_opclass cla_tup;
4695 Oid amid;
4696 Oid opfamily;
4697 Oid opcintype;
4698 Oid pfeqop;
4699 Oid ppeqop;
4700 Oid ffeqop;
4701 int16 eqstrategy;
4703 /* We need several fields out of the pg_opclass entry */
4715 /*
4716 * Check it's a btree; currently this can never fail since no other
4717 * index AMs support unique indexes. If we ever did have other types
4718 * of unique indexes, we'd need a way to determine which operator
4719 * strategy number is equality. (Is it reasonable to insist that
4720 * every such index AM use btree's number for equality?)
4721 */
4726 /*
4727 * There had better be a primary equality operator for the index.
4728 * We'll use it for PK = PK comparisons.
4729 */
4731 eqstrategy);
4737 /*
4738 * Are there equality operators that take exactly the FK type? Assume
4739 * we should look through any domain here.
4740 */
4744 eqstrategy);
4747 eqstrategy);
4748 else
4752 {
4753 /*
4754 * Otherwise, look for an implicit cast from the FK type to the
4755 * opcintype, and if found, use the primary equality operator.
4756 * This is a bit tricky because opcintype might be a polymorphic
4757 * type such as ANYARRAY or ANYENUM; so what we have to test is
4758 * whether the two actual column types can be concurrently cast to
4759 * that type. (Otherwise, we'd fail to reject combinations such
4760 * as int[] and point[].)
4761 */
4770 COERCION_IMPLICIT))
4772 }
4790 }
4792 /*
4793 * Record the FK constraint in pg_constraint.
4794 */
4797 CONSTRAINT_FOREIGN,
4801 fkattnum,
4802 numfks,
4804 * constraint */
4806 pkattnum,
4807 pfeqoperators,
4808 ppeqoperators,
4809 ffeqoperators,
4810 numpks,
4814 indexOid,
4816 NULL,
4817 NULL,
4821 /*
4822 * Create the triggers that will enforce the constraint.
4823 */
4826 /*
4827 * Tell Phase 3 to check that the constraint is satisfied by existing rows
4828 * (we can skip this during table creation).
4829 */
4831 {
4842 }
4844 /*
4845 * Close pk table, but keep lock until we've committed.
4846 */
4848 }
4851 /*
4852 * transformColumnNameList - transform list of column names
4853 *
4854 * Lookup each name and return its attnum and type OID
4855 */
4856 static int
4859 {
4865 {
4867 HeapTuple atttuple;
4874 attname)));
4879 INDEX_MAX_KEYS)));
4883 attnum++;
4884 }
4887 }
4889 /*
4890 * transformFkeyGetPrimaryKey -
4891 *
4892 * Look up the names, attnums, and types of the primary key attributes
4893 * for the pkrel. Also return the index OID and index opclasses of the
4894 * index supporting the primary key.
4895 *
4896 * All parameters except pkrel are output parameters. Also, the function
4897 * return value is the number of attributes in the primary key.
4898 *
4899 * Used when the column list in the REFERENCES specification is omitted.
4900 */
4901 static int
4906 {
4911 Datum indclassDatum;
4916 /*
4917 * Get the list of index OIDs for the table from the relcache, and look up
4918 * each one in the pg_index syscache until we find one marked primary key
4919 * (hopefully there isn't more than one such).
4920 */
4926 {
4936 {
4939 }
4941 }
4945 /*
4946 * Check that we found it
4947 */
4954 /* Must get indclass the hard way */
4960 /*
4961 * Now build the list of PK attributes from the indkey definition (we
4962 * assume a primary key cannot have expressional elements)
4963 */
4966 {
4974 }
4979 }
4981 /*
4982 * transformFkeyCheckAttrs -
4983 *
4984 * Make sure that the attributes of a referenced table belong to a unique
4985 * (or primary key) constraint. Return the OID of the index supporting
4986 * the constraint, as well as the opclasses associated with the index
4987 * columns.
4988 */
4989 static Oid
4993 {
4999 /*
5000 * Get the list of index OIDs for the table from the relcache, and look up
5001 * each one in the pg_index syscache, and match unique indexes to the list
5002 * of attnums we are given.
5003 */
5007 {
5008 HeapTuple indexTuple;
5009 Form_pg_index indexStruct;
5011 j;
5021 /*
5022 * Must have the right number of columns; must be unique and not a
5023 * partial index; forget it if there are any expressions, too
5024 */
5029 {
5030 /* Must get indclass the hard way */
5031 Datum indclassDatum;
5040 /*
5041 * The given attnum list may match the index columns in any order.
5042 * Check that each list is a subset of the other.
5043 */
5045 {
5048 {
5050 {
5053 }
5054 }
5057 }
5059 {
5061 {
5064 {
5066 {
5070 }
5071 }
5074 }
5075 }
5076 }
5080 }
5091 }
5093 /* Permissions checks for ADD FOREIGN KEY */
5094 static void
5096 {
5098 AclResult aclresult;
5101 /* Okay if we have relation-level REFERENCES permission */
5103 ACL_REFERENCES);
5106 /* Else we must have REFERENCES on each column */
5108 {
5114 }
5115 }
5117 /*
5118 * Scan the existing rows in a table to verify they meet a proposed FK
5119 * constraint.
5120 *
5121 * Caller must have opened and locked both relations.
5122 */
5123 static void
5125 Relation rel,
5126 Relation pkrel,
5127 Oid constraintOid)
5128 {
5129 HeapScanDesc scan;
5130 HeapTuple tuple;
5131 Trigger trig;
5133 /*
5134 * Build a trigger call structure; we'll need it either way.
5135 */
5145 /* we needn't fill in tgargs */
5147 /*
5148 * See if we can do it with a single LEFT JOIN query. A FALSE result
5149 * indicates we must proceed with the fire-the-trigger method.
5150 */
5154 /*
5155 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
5156 * if that tuple had just been inserted. If any of those fail, it should
5157 * ereport(ERROR) and that's that.
5158 */
5162 {
5163 FunctionCallInfoData fcinfo;
5164 TriggerData trigdata;
5166 /*
5167 * Make a call to the trigger function
5168 *
5169 * No parameters are passed, but we do set a context
5170 */
5173 /*
5174 * We assume RI_FKey_check_ins won't look at flinfo...
5175 */
5188 }
5191 }
5193 static void
5196 {
5205 /* Either ON INSERT or ON UPDATE */
5207 {
5210 }
5211 else
5212 {
5215 }
5225 /* Make changes-so-far visible */
5227 }
5229 /*
5230 * Create the triggers that implement an FK constraint.
5231 */
5232 static void
5234 Oid constraintOid)
5235 {
5239 /*
5240 * Reconstruct a RangeVar for my relation (not passed in, unfortunately).
5241 */
5246 /* Make changes-so-far visible */
5249 /*
5250 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the CHECK
5251 * action for both INSERTs and UPDATEs on the referencing table.
5252 */
5256 /*
5257 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
5258 * DELETE action on the referenced table.
5259 */
5269 {
5299 }
5304 /* Make changes-so-far visible */
5307 /*
5308 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
5309 * UPDATE action on the referenced table.
5310 */
5320 {
5350 }
5354 }
5356 /*
5357 * ALTER TABLE DROP CONSTRAINT
5358 *
5359 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
5360 */
5361 static void
5363 DropBehavior behavior,
5365 {
5368 Relation conrel;
5369 Form_pg_constraint con;
5370 SysScanDesc scan;
5371 ScanKeyData key;
5372 HeapTuple tuple;
5376 /* At top level, permission check was done in ATPrepCmd, else do it */
5382 /*
5383 * Find and drop the target constraint
5384 */
5386 Anum_pg_constraint_conrelid,
5393 {
5394 ObjectAddress conobj;
5401 /* Don't drop inherited constraints */
5408 /* Right now only CHECK constraints can be inherited */
5412 /*
5413 * Perform the actual constraint deletion
5414 */
5422 }
5432 /*
5433 * Propagate to children as appropriate. Unlike most other ALTER
5434 * routines, we have to do this one level of recursion at a time; we can't
5435 * use find_all_inheritors to do it in one pass.
5436 */
5439 AccessExclusiveLock);
5440 else
5444 {
5446 Relation childrel;
5448 /* find_inheritance_children already got lock */
5453 Anum_pg_constraint_conrelid,
5462 {
5463 HeapTuple copy_tuple;
5467 /* Right now only CHECK constraints can be inherited */
5484 {
5485 /*
5486 * If the child constraint has other definition sources, just
5487 * decrement its inheritance count; if not, recurse to delete
5488 * it.
5489 */
5491 {
5492 /* Time to delete this child constraint, too */
5495 }
5496 else
5497 {
5498 /* Child constraint must survive my deletion */
5503 /* Make update visible */
5505 }
5506 }
5507 else
5508 {
5509 /*
5510 * If we were told to drop ONLY in this table (no recursion),
5511 * we need to mark the inheritors' constraints as locally
5512 * defined rather than inherited.
5513 */
5520 /* Make update visible */
5522 }
5525 }
5533 constrName,
5537 }
5540 }
5542 /*
5543 * ALTER COLUMN TYPE
5544 */
5545 static void
5550 {
5553 HeapTuple tuple;
5554 Form_pg_attribute attTup;
5555 AttrNumber attnum;
5556 Oid targettype;
5557 int32 targettypmod;
5562 /* lookup the attribute so we can check inheritance status */
5572 /* Can't alter a system attribute */
5577 colName)));
5579 /* Don't alter inherited columns */
5584 colName)));
5586 /* Look up the target type */
5589 /* make sure datatype is legal for a column */
5592 /*
5593 * Set up an expression to transform the old data value to the new type.
5594 * If a USING option was given, transform and use that expression, else
5595 * just take the old value and try to coerce it. We do this first so that
5596 * type incompatibility can be detected before we waste effort, and
5597 * because we need the expression to be parsed against the original table
5598 * rowtype.
5599 */
5601 {
5604 /* Expression must be able to access vars of old table */
5606 rel,
5607 NULL,
5614 /* It can't return a set */
5620 /* No subplans or aggregates, either... */
5633 }
5634 else
5635 {
5639 }
5644 COERCION_ASSIGNMENT,
5645 COERCE_IMPLICIT_CAST,
5653 /*
5654 * Add a work queue item to make ATRewriteTable update the column
5655 * contents.
5656 */
5665 /*
5666 * The recursion case is handled by ATSimpleRecursion. However, if we are
5667 * told not to recurse, there had better not be any child tables; else the
5668 * alter would put them out of step.
5669 */
5677 colName)));
5678 }
5680 static void
5683 {
5684 HeapTuple heapTup;
5685 Form_pg_attribute attTup;
5686 AttrNumber attnum;
5687 HeapTuple typeTuple;
5688 Form_pg_type tform;
5689 Oid targettype;
5690 int32 targettypmod;
5692 Relation attrelation;
5693 Relation depRel;
5695 SysScanDesc scan;
5696 HeapTuple depTup;
5700 /* Look up the target column */
5710 /* Check for multiple ALTER TYPE on same column --- can't cope */
5716 colName)));
5718 /* Look up the target type (should not fail, since prep found it) */
5723 /*
5724 * If there is a default expression for the column, get it and ensure we
5725 * can coerce it to the new datatype. (We must do this before changing
5726 * the column type, because build_column_default itself will try to
5727 * coerce, and will not issue the error message we want if it fails.)
5728 *
5729 * We remove any implicit coercion steps at the top level of the old
5730 * default expression; this has been agreed to satisfy the principle of
5731 * least surprise. (The conversion to the new column type should act like
5732 * it started from what the user sees as the stored expression, and the
5733 * implicit coercions aren't going to be shown.)
5734 */
5736 {
5743 COERCION_ASSIGNMENT,
5744 COERCE_IMPLICIT_CAST,
5751 }
5752 else
5755 /*
5756 * Find everything that depends on the column (constraints, indexes, etc),
5757 * and record enough information to let us recreate the objects.
5758 *
5759 * The actual recreation does not happen here, but only after we have
5760 * performed all the individual ALTER TYPE operations. We have to save
5761 * the info before executing ALTER TYPE, though, else the deparser will
5762 * get confused.
5763 *
5764 * There could be multiple entries for the same object, so we must check
5765 * to ensure we process each one only once. Note: we assume that an index
5766 * that implements a constraint will not show a direct dependency on the
5767 * column.
5768 */
5772 Anum_pg_depend_refclassid,
5776 Anum_pg_depend_refobjid,
5780 Anum_pg_depend_refobjsubid,
5788 {
5790 ObjectAddress foundObject;
5792 /* We don't expect any PIN dependencies on columns */
5801 {
5803 {
5807 {
5810 {
5815 }
5816 }
5818 {
5819 /*
5820 * This must be a SERIAL column's sequence. We need
5821 * not do anything to it.
5822 */
5824 }
5825 else
5826 {
5827 /* Not expecting any other direct dependencies... */
5830 }
5832 }
5838 {
5841 /*
5842 * Put NORMAL dependencies at the front of the list and
5843 * AUTO dependencies at the back. This makes sure that
5844 * foreign-key constraints depending on this column will
5845 * be dropped before unique or primary-key constraints of
5846 * the column; which we must have because the FK
5847 * constraints depend on the indexes belonging to the
5848 * unique constraints.
5849 */
5851 {
5858 }
5859 else
5860 {
5866 defstring);
5867 }
5868 }
5872 /* XXX someday see if we can cope with revising views */
5878 colName)));
5883 /*
5884 * Ignore the column's default expression, since we will fix
5885 * it below.
5886 */
5905 /*
5906 * We don't expect any of these sorts of objects to depend on
5907 * a column.
5908 */
5916 }
5917 }
5921 /*
5922 * Now scan for dependencies of this column on other things. The only
5923 * thing we should find is the dependency on the column datatype, which we
5924 * want to remove.
5925 */
5927 Anum_pg_depend_classid,
5931 Anum_pg_depend_objid,
5935 Anum_pg_depend_objsubid,
5943 {
5954 }
5960 /*
5961 * Here we go --- change the recorded column type. (Note heapTup is a
5962 * copy of the syscache entry, so okay to scribble on.)
5963 */
5976 /* keep system catalog indexes current */
5981 /* Install dependency on new datatype */
5984 /*
5985 * Drop any pg_statistic entry for the column, since it's now wrong type
5986 */
5989 /*
5990 * Update the default, if present, by brute force --- remove and re-add
5991 * the default. Probably unsafe to take shortcuts, since the new version
5992 * may well have additional dependencies. (It's okay to do this now,
5993 * rather than after other ALTER TYPE commands, since the default won't
5994 * depend on other column types.)
5995 */
5997 {
5998 /* Must make new row visible since it will be updated again */
6001 /*
6002 * We use RESTRICT here for safety, but at present we do not expect
6003 * anything to depend on the default.
6004 */
6008 }
6010 /* Cleanup */
6012 }
6014 /*
6015 * Cleanup after we've finished all the ALTER TYPE operations for a
6016 * particular relation. We have to drop and recreate all the indexes
6017 * and constraints that depend on the altered columns.
6018 */
6019 static void
6021 {
6022 ObjectAddress obj;
6025 /*
6026 * Re-parse the index and constraint definitions, and attach them to the
6027 * appropriate work queue entries. We do this before dropping because in
6028 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
6029 * lock on the table the constraint is attached to, and we need to get
6030 * that before dropping. It's safe because the parser won't actually look
6031 * at the catalogs to detect the existing entry.
6032 */
6038 /*
6039 * Now we can drop the existing constraints and indexes --- constraints
6040 * first, since some of them might depend on the indexes. In fact, we
6041 * have to delete FOREIGN KEY constraints before UNIQUE constraints, but
6042 * we already ordered the constraint list to ensure that would happen. It
6043 * should be okay to use DROP_RESTRICT here, since nothing else should be
6044 * depending on these objects.
6045 */
6047 {
6052 }
6055 {
6060 }
6062 /*
6063 * The objects will get recreated during subsequent passes over the work
6064 * queue.
6065 */
6066 }
6068 static void
6070 {
6075 /*
6076 * We expect that we will get only ALTER TABLE and CREATE INDEX
6077 * statements. Hence, there is no need to pass them through
6078 * parse_analyze() or the rewriter, but instead we need to pass them
6079 * through parse_utilcmd.c to make them ready for execution.
6080 */
6084 {
6090 cmd));
6094 cmd));
6095 else
6097 }
6099 /*
6100 * Attach each generated command to the proper place in the work queue.
6101 * Note this could result in creation of entirely new work-queue entries.
6102 */
6104 {
6106 Relation rel;
6110 {
6112 {
6125 }
6127 {
6134 {
6138 {
6151 }
6152 }
6155 }
6159 }
6160 }
6161 }
6164 /*
6165 * ALTER TABLE OWNER
6166 *
6167 * recursing is true if we are recursing from a table to its indexes,
6168 * sequences, or toast table. We don't allow the ownership of those things to
6169 * be changed separately from the parent table. Also, we can skip permission
6170 * checks (this is necessary not just an optimization, else we'd fail to
6171 * handle toast tables properly).
6172 *
6173 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
6174 * free-standing composite type.
6175 */
6176 void
6178 {
6179 Relation target_rel;
6180 Relation class_rel;
6181 HeapTuple tuple;
6182 Form_pg_class tuple_class;
6184 /*
6185 * Get exclusive lock till end of transaction on the target table. Use
6186 * relation_open so that we can work on indexes and sequences.
6187 */
6190 /* Get its pg_class tuple, too */
6200 /* Can we change the ownership of this tuple? */
6202 {
6205 /* ok to change owner */
6209 {
6210 /*
6211 * Because ALTER INDEX OWNER used to be allowed, and in fact
6212 * is generated by old versions of pg_dump, we give a warning
6213 * and do nothing rather than erroring out. Also, to avoid
6214 * unnecessary chatter while restoring those old dumps, say
6215 * nothing at all if the command would be a no-op anyway.
6216 */
6223 /* quick hack to exit via the no-op path */
6225 }
6230 {
6231 /* if it's an owned sequence, disallow changing it by itself */
6232 Oid tableId;
6233 int32 colId;
6243 }
6257 /* FALL THRU */
6263 }
6265 /*
6266 * If the new owner is the same as the existing owner, consider the
6267 * command to have succeeded. This is for dump restoration purposes.
6268 */
6270 {
6275 Datum aclDatum;
6277 HeapTuple newtuple;
6279 /* skip permission checks when recursing to index or toast table */
6281 {
6282 /* Superusers can always do it */
6284 {
6286 AclResult aclresult;
6288 /* Otherwise, must be owner of the existing object */
6293 /* Must be able to become new owner */
6296 /* New owner must have CREATE privilege on namespace */
6298 ACL_CREATE);
6302 }
6303 }
6311 /*
6312 * Determine the modified ACL for the new owner. This is only
6313 * necessary when the ACL is non-null.
6314 */
6316 Anum_pg_class_relacl,
6319 {
6324 }
6326 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
6333 /*
6334 * Update owner dependency reference, if any. A composite type has
6335 * none, because it's tracked for the pg_type entry instead of here;
6336 * indexes and TOAST tables don't have their own entries either.
6337 */
6342 newOwnerId);
6344 /*
6345 * Also change the ownership of the table's rowtype, if it has one
6346 */
6351 /*
6352 * If we are operating on a table, also change the ownership of any
6353 * indexes and sequences that belong to the table, as well as the
6354 * table's toast table (if it has one)
6355 */
6358 {
6362 /* Find all the indexes belonging to this relation */
6365 /* For each index, recursively change its ownership */
6370 }
6373 {
6374 /* If it has a toast table, recurse to change its ownership */
6379 /* If it has dependent sequences, recurse to change them too */
6381 }
6382 }
6387 }
6389 /*
6390 * change_owner_recurse_to_sequences
6391 *
6392 * Helper function for ATExecChangeOwner. Examines pg_depend searching
6393 * for sequences that are dependent on serial columns, and changes their
6394 * ownership.
6395 */
6396 static void
6398 {
6399 Relation depRel;
6400 SysScanDesc scan;
6402 HeapTuple tup;
6404 /*
6405 * SERIAL sequences are those having an auto dependency on one of the
6406 * table's columns (we don't care *which* column, exactly).
6407 */
6411 Anum_pg_depend_refclassid,
6415 Anum_pg_depend_refobjid,
6418 /* we leave refobjsubid unspecified */
6424 {
6426 Relation seqRel;
6428 /* skip dependencies other than auto dependencies on columns */
6435 /* Use relation_open just in case it's an index */
6438 /* skip non-sequence relations */
6440 {
6441 /* No need to keep the lock */
6444 }
6446 /* We don't need to close the sequence while we alter it. */
6449 /* Now we can close it. Keep the lock till end of transaction. */
6451 }
6456 }
6458 /*
6459 * ALTER TABLE CLUSTER ON
6460 *
6461 * The only thing we have to do is to change the indisclustered bits.
6462 */
6463 static void
6465 {
6466 Oid indexOid;
6476 /* Check index is valid to cluster on */
6479 /* And do the work */
6481 }
6483 /*
6484 * ALTER TABLE SET WITHOUT CLUSTER
6485 *
6486 * We have to find any indexes on the table that have indisclustered bit
6487 * set and turn it off.
6488 */
6489 static void
6491 {
6493 }
6495 /*
6496 * ALTER TABLE SET TABLESPACE
6497 */
6498 static void
6500 {
6501 Oid tablespaceId;
6502 AclResult aclresult;
6504 /* Check that the tablespace exists */
6511 /* Check its permissions */
6516 /* Save info for Phase 3 to do the real work */
6522 }
6524 /*
6525 * ALTER TABLE/INDEX SET (...) or RESET (...)
6526 */
6527 static void
6529 {
6530 Oid relid;
6531 Relation pgclass;
6532 HeapTuple tuple;
6533 HeapTuple newtuple;
6534 Datum datum;
6536 Datum newOptions;
6547 /* Get the old reloptions */
6557 /* Generate new proposed reloptions (text array) */
6561 /* Validate */
6563 {
6577 }
6579 /*
6580 * All we need do here is update the pg_class row; the new options will be
6581 * propagated into relcaches during post-commit cache inval.
6582 */
6589 else
6605 /* repeat the whole exercise for the toast table, if there's one */
6607 {
6608 Relation toastrel;
6613 /* Get the old reloptions */
6633 else
6650 }
6653 }
6655 /*
6656 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
6657 * rewriting to be done, so we just want to copy the data as fast as possible.
6658 */
6659 static void
6661 {
6662 Relation rel;
6663 Oid oldTableSpace;
6664 Oid reltoastrelid;
6665 Oid reltoastidxid;
6666 Oid newrelfilenode;
6667 RelFileNode newrnode;
6668 SMgrRelation dstrel;
6669 Relation pg_class;
6670 HeapTuple tuple;
6671 Form_pg_class rd_rel;
6672 ForkNumber forkNum;
6674 /*
6675 * Need lock here in case we are recursing to toast table or index
6676 */
6679 /*
6680 * We can never allow moving of shared or nailed-in-cache relations,
6681 * because we can't support changing their reltablespace values.
6682 */
6689 /* Can't move a non-shared relation into pg_global */
6695 /*
6696 * Don't allow moving temp tables of other backends ... their local buffer
6697 * manager is not going to cope.
6698 */
6704 /*
6705 * No work if no change in tablespace.
6706 */
6710 {
6713 }
6718 /* Get a modifiable copy of the relation's pg_class row */
6728 /*
6729 * Since we copy the file directly without looking at the shared buffers,
6730 * we'd better first flush out any pages of the source relation that are
6731 * in shared buffers. We assume no new changes will be made while we are
6732 * holding exclusive lock on the rel.
6733 */
6736 /*
6737 * Relfilenodes are not unique across tablespaces, so we need to allocate
6738 * a new one in the new tablespace.
6739 */
6742 NULL);
6744 /* Open old and new relation */
6752 /*
6753 * Create and copy all forks of the relation, and schedule unlinking of
6754 * old physical files.
6755 *
6756 * NOTE: any conflict in relfilenode value will be caught in
6757 * RelationCreateStorage().
6758 */
6761 /* copy main fork */
6764 /* copy those extra forks that exist */
6766 {
6768 {
6771 }
6772 }
6774 /* drop old relation, and close new one */
6778 /* update the pg_class row */
6790 /* Make sure the reltablespace change is visible */
6793 /* Move associated toast relation and/or index, too */
6798 }
6800 /*
6801 * Copy data, block by block
6802 */
6803 static void
6806 {
6808 BlockNumber nblocks;
6809 BlockNumber blkno;
6813 /*
6814 * We need to log the copied data in WAL iff WAL archiving is enabled AND
6815 * it's not a temp rel.
6816 */
6822 {
6825 /* XLOG stuff */
6829 /*
6830 * Now write the page. We say isTemp = true even if it's not a temp
6831 * rel, because there's no need for smgr to schedule an fsync for this
6832 * write; we'll do it ourselves below.
6833 */
6835 }
6837 /*
6838 * If the rel isn't temp, we must fsync it down to disk before it's safe
6839 * to commit the transaction. (For a temp rel we don't care since the rel
6840 * will be uninteresting after a crash anyway.)
6841 *
6842 * It's obvious that we must do this when not WAL-logging the copy. It's
6843 * less obvious that we have to do it even if we did WAL-log the copied
6844 * pages. The reason is that since we're copying outside shared buffers, a
6845 * CHECKPOINT occurring during the copy has no way to flush the previously
6846 * written data to disk (indeed it won't know the new rel even exists). A
6847 * crash later on would replay WAL from the checkpoint, therefore it
6848 * wouldn't replay our earlier WAL entries. If we do not fsync those pages
6849 * here, they might still not be on disk when the crash occurs.
6850 */
6853 }
6855 /*
6856 * ALTER TABLE ENABLE/DISABLE TRIGGER
6857 *
6858 * We just pass this off to trigger.c.
6859 */
6860 static void
6863 {
6865 }
6867 /*
6868 * ALTER TABLE ENABLE/DISABLE RULE
6869 *
6870 * We just pass this off to rewriteDefine.c.
6871 */
6872 static void
6875 {
6877 }
6879 /*
6880 * ALTER TABLE INHERIT
6881 *
6882 * Add a parent to the child's parents. This verifies that all the columns and
6883 * check constraints of the parent appear in the child and that they have the
6884 * same data types and expressions.
6885 */
6886 static void
6888 {
6889 Relation parent_rel,
6890 catalogRelation;
6891 SysScanDesc scan;
6892 ScanKeyData key;
6893 HeapTuple inheritsTuple;
6894 int32 inhseqno;
6897 /*
6898 * AccessShareLock on the parent is what's obtained during normal CREATE
6899 * TABLE ... INHERITS ..., so should be enough here.
6900 */
6903 /*
6904 * Must be owner of both parent and child -- child was checked by
6905 * ATSimplePermissions call in ATPrepCmd
6906 */
6909 /* Permanent rels cannot inherit from temporary ones */
6916 /*
6917 * Check for duplicates in the list of parents, and determine the highest
6918 * inhseqno already present; we'll use the next one for the new parent.
6919 * (Note: get RowExclusiveLock because we will write pg_inherits below.)
6920 *
6921 * Note: we do not reject the case where the child already inherits from
6922 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
6923 */
6926 Anum_pg_inherits_inhrelid,
6932 /* inhseqno sequences start at 1 */
6935 {
6945 }
6948 /*
6949 * Prevent circularity by seeing if proposed parent inherits from child.
6950 * (In particular, this disallows making a rel inherit from itself.)
6951 *
6952 * This is not completely bulletproof because of race conditions: in
6953 * multi-level inheritance trees, someone else could concurrently be
6954 * making another inheritance link that closes the loop but does not join
6955 * either of the rels we have locked. Preventing that seems to require
6956 * exclusive locks on the entire inheritance tree, which is a cure worse
6957 * than the disease. find_all_inheritors() will cope with circularity
6958 * anyway, so don't sweat it too much.
6959 *
6960 * We use weakest lock we can on child's children, namely AccessShareLock.
6961 */
6963 AccessShareLock);
6973 /* If parent has OIDs then child must have OIDs */
6981 /* Match up the columns and bump attinhcount as needed */
6984 /* Match up the constraints and bump coninhcount as needed */
6987 /*
6988 * OK, it looks valid. Make the catalog entries that show inheritance.
6989 */
6993 catalogRelation);
6995 /* Now we're done with pg_inherits */
6998 /* keep our lock on the parent relation until commit */
7000 }
7002 /*
7003 * Obtain the source-text form of the constraint expression for a check
7004 * constraint, given its pg_constraint tuple
7005 */
7008 {
7009 Form_pg_constraint con;
7011 Datum attr;
7012 Datum expr;
7022 }
7024 /*
7025 * Determine whether two check constraints are functionally equivalent
7026 *
7027 * The test we apply is to see whether they reverse-compile to the same
7028 * source string. This insulates us from issues like whether attributes
7029 * have the same physical column numbers in parent and child relations.
7030 */
7031 static bool
7033 {
7042 else
7044 }
7046 /*
7047 * Check columns in child table match up with columns in parent, and increment
7048 * their attinhcount.
7049 *
7050 * Called by ATExecAddInherit
7051 *
7052 * Currently all parent columns must be found in child. Missing columns are an
7053 * error. One day we might consider creating new columns like CREATE TABLE
7054 * does. However, that is widely unpopular --- in the common use case of
7055 * partitioned tables it's a foot-gun.
7056 *
7057 * The data type must match exactly. If the parent column is NOT NULL then
7058 * the child must be as well. Defaults are not compared, however.
7059 */
7060 static void
7062 {
7063 Relation attrrel;
7064 AttrNumber parent_attno;
7066 TupleDesc tupleDesc;
7068 HeapTuple tuple;
7077 {
7081 /* Ignore dropped columns in the parent. */
7085 /* Find same column in child (matching on column name). */
7087 attributeName);
7089 {
7090 /* Check they are same type and typmod */
7099 attributeName)));
7105 attributeName)));
7107 /*
7108 * OK, bump the child column's inheritance count. (If we fail
7109 * later on, this change will just roll back.)
7110 */
7115 }
7116 else
7117 {
7121 attributeName)));
7122 }
7123 }
7126 }
7128 /*
7129 * Check constraints in child table match up with constraints in parent,
7130 * and increment their coninhcount.
7131 *
7132 * Called by ATExecAddInherit
7133 *
7134 * Currently all constraints in parent must be present in the child. One day we
7135 * may consider adding new constraints like CREATE TABLE does. We may also want
7136 * to allow an optional flag on parent table constraints indicating they are
7137 * intended to ONLY apply to the master table, not to the children. That would
7138 * make it possible to ensure no records are mistakenly inserted into the
7139 * master in partitioned tables rather than the appropriate child.
7140 *
7141 * XXX This is O(N^2) which may be an issue with tables with hundreds of
7142 * constraints. As long as tables have more like 10 constraints it shouldn't be
7143 * a problem though. Even 100 constraints ought not be the end of the world.
7144 */
7145 static void
7147 {
7148 Relation catalog_relation;
7149 TupleDesc tuple_desc;
7150 SysScanDesc parent_scan;
7151 ScanKeyData parent_key;
7152 HeapTuple parent_tuple;
7157 /* Outer loop scans through the parent's constraint definitions */
7159 Anum_pg_constraint_conrelid,
7166 {
7168 SysScanDesc child_scan;
7169 ScanKeyData child_key;
7170 HeapTuple child_tuple;
7176 /* Search for a child constraint matching this one */
7178 Anum_pg_constraint_conrelid,
7185 {
7187 HeapTuple child_copy;
7203 /*
7204 * OK, bump the child constraint's inheritance count. (If we fail
7205 * later on, this change will just roll back.)
7206 */
7216 }
7225 }
7229 }
7231 /*
7232 * ALTER TABLE NO INHERIT
7233 *
7234 * Drop a parent from the child's parents. This just adjusts the attinhcount
7235 * and attislocal of the columns and removes the pg_inherit and pg_depend
7236 * entries.
7237 *
7238 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
7239 * up attislocal stays true, which means if a child is ever removed from a
7240 * parent then its columns will never be automatically dropped which may
7241 * surprise. But at least we'll never surprise by dropping columns someone
7242 * isn't expecting to be dropped which would actually mean data loss.
7243 *
7244 * coninhcount and conislocal for inherited constraints are adjusted in
7245 * exactly the same way.
7246 */
7247 static void
7249 {
7250 Relation parent_rel;
7251 Relation catalogRelation;
7252 SysScanDesc scan;
7254 HeapTuple inheritsTuple,
7255 attributeTuple,
7256 constraintTuple,
7257 depTuple;
7261 /*
7262 * AccessShareLock on the parent is probably enough, seeing that DROP
7263 * TABLE doesn't lock parent tables at all. We need some lock since we'll
7264 * be inspecting the parent's schema.
7265 */
7268 /*
7269 * We don't bother to check ownership of the parent table --- ownership of
7270 * the child is presumed enough rights.
7271 */
7273 /*
7274 * Find and destroy the pg_inherits entry linking the two, or error out if
7275 * there is none.
7276 */
7279 Anum_pg_inherits_inhrelid,
7286 {
7287 Oid inhparent;
7291 {
7295 }
7296 }
7308 /*
7309 * Search through child columns looking for ones matching parent rel
7310 */
7313 Anum_pg_attribute_attrelid,
7319 {
7322 /* Ignore if dropped or not inherited */
7330 {
7331 /* Decrement inhcount and possibly set islocal to true */
7342 }
7343 }
7347 /*
7348 * Likewise, find inherited check constraints and disinherit them. To do
7349 * this, we first need a list of the names of the parent's check
7350 * constraints. (We cheat a bit by only checking for name matches,
7351 * assuming that the expressions will match.)
7352 */
7355 Anum_pg_constraint_conrelid,
7364 {
7369 }
7373 /* Now scan the child's constraints */
7375 Anum_pg_constraint_conrelid,
7382 {
7392 {
7394 {
7397 }
7398 }
7401 {
7402 /* Decrement inhcount and possibly set islocal to true */
7417 }
7418 }
7423 /*
7424 * Drop the dependency
7425 *
7426 * There's no convenient way to do this, so go trawling through pg_depend
7427 */
7431 Anum_pg_depend_classid,
7435 Anum_pg_depend_objid,
7439 Anum_pg_depend_objsubid,
7447 {
7455 }
7460 /* keep our lock on the parent relation until commit */
7462 }
7465 /*
7466 * Execute ALTER TABLE SET SCHEMA
7467 *
7468 * Note: caller must have checked ownership of the relation already
7469 */
7470 void
7472 ObjectType stmttype)
7473 {
7474 Relation rel;
7475 Oid relid;
7476 Oid oldNspOid;
7477 Oid nspOid;
7478 Relation classRel;
7485 /* Check relation type against type specified in the ALTER command */
7487 {
7490 /*
7491 * For mostly-historical reasons, we allow ALTER TABLE to apply to
7492 * all relation types.
7493 */
7514 }
7516 /* Can we change the schema of this tuple? */
7518 {
7521 /* ok to change schema */
7524 {
7525 /* if it's an owned sequence, disallow moving it by itself */
7526 Oid tableId;
7527 int32 colId;
7536 }
7547 /* FALL THRU */
7553 }
7555 /* get schema OID and check its permissions */
7563 newschema)));
7565 /* disallow renaming into or out of temp schemas */
7571 /* same for TOAST schema */
7577 /* OK, modify the pg_class row and pg_depend entry */
7582 /* Fix the table's rowtype too */
7585 /* Fix other dependent stuff */
7587 {
7591 }
7595 /* close rel, but keep lock until commit */
7597 }
7599 /*
7600 * The guts of relocating a relation to another namespace: fix the pg_class
7601 * entry, and the pg_depend entry if any. Caller must already have
7602 * opened and write-locked pg_class.
7603 */
7604 void
7608 {
7609 HeapTuple classTup;
7610 Form_pg_class classForm;
7621 /* check for duplicate name (more friendly than unique-index failure) */
7630 /* classTup is a copy, so OK to scribble on */
7636 /* Update dependency on schema if caller said so */
7644 }
7646 /*
7647 * Move all indexes for the specified relation to another namespace.
7648 *
7649 * Note: we assume adequate permission checking was done by the caller,
7650 * and that the caller has a suitable lock on the owning relation.
7651 */
7652 static void
7655 {
7662 {
7665 /*
7666 * Note: currently, the index will not have its own dependency on the
7667 * namespace, so we don't need to do changeDependencyFor(). There's no
7668 * rowtype in pg_type, either.
7669 */
7673 }
7676 }
7678 /*
7679 * Move all SERIAL-column sequences of the specified relation to another
7680 * namespace.
7681 *
7682 * Note: we assume adequate permission checking was done by the caller,
7683 * and that the caller has a suitable lock on the owning relation.
7684 */
7685 static void
7688 {
7689 Relation depRel;
7690 SysScanDesc scan;
7692 HeapTuple tup;
7694 /*
7695 * SERIAL sequences are those having an auto dependency on one of the
7696 * table's columns (we don't care *which* column, exactly).
7697 */
7701 Anum_pg_depend_refclassid,
7705 Anum_pg_depend_refobjid,
7708 /* we leave refobjsubid unspecified */
7714 {
7716 Relation seqRel;
7718 /* skip dependencies other than auto dependencies on columns */
7725 /* Use relation_open just in case it's an index */
7728 /* skip non-sequence relations */
7730 {
7731 /* No need to keep the lock */
7734 }
7736 /* Fix the pg_class and pg_depend entries */
7741 /*
7742 * Sequences have entries in pg_type. We need to be careful to move
7743 * them to the new namespace, too.
7744 */
7748 /* Now we can close it. Keep the lock till end of transaction. */
7750 }
7755 }
7758 /*
7759 * This code supports
7760 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
7761 *
7762 * Because we only support this for TEMP tables, it's sufficient to remember
7763 * the state in a backend-local data structure.
7764 */
7766 /*
7767 * Register a newly-created relation's ON COMMIT action.
7768 */
7769 void
7771 {
7773 MemoryContext oldcxt;
7775 /*
7776 * We needn't bother registering the relation unless there is an ON COMMIT
7777 * action we need to take.
7778 */
7793 }
7795 /*
7796 * Unregister any ON COMMIT action when a relation is deleted.
7797 *
7798 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
7799 */
7800 void
7802 {
7806 {
7810 {
7813 }
7814 }
7815 }
7817 /*
7818 * Perform ON COMMIT actions.
7819 *
7820 * This is invoked just before actually committing, since it's possible
7821 * to encounter errors.
7822 */
7823 void
7825 {
7830 {
7833 /* Ignore entry if already dropped in this xact */
7838 {
7841 /* Do nothing (there shouldn't be such entries, actually) */
7847 {
7848 ObjectAddress object;
7855 /*
7856 * Note that table deletion will call
7857 * remove_on_commit_action, so the entry should get marked
7858 * as deleted.
7859 */
7862 }
7863 }
7864 }
7866 {
7869 }
7870 }
7872 /*
7873 * Post-commit or post-abort cleanup for ON COMMIT management.
7874 *
7875 * All we do here is remove no-longer-needed OnCommitItem entries.
7876 *
7877 * During commit, remove entries that were deleted during this transaction;
7878 * during abort, remove those created during this transaction.
7879 */
7880 void
7882 {
7890 {
7895 {
7896 /* cur_item must be removed */
7901 else
7903 }
7904 else
7905 {
7906 /* cur_item must be preserved */
7911 }
7912 }
7913 }
7915 /*
7916 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
7917 *
7918 * During subabort, we can immediately remove entries created during this
7919 * subtransaction. During subcommit, just relabel entries marked during
7920 * this subtransaction as being the parent's responsibility.
7921 */
7922 void
7924 SubTransactionId parentSubid)
7925 {
7933 {
7937 {
7938 /* cur_item must be removed */
7943 else
7945 }
7946 else
7947 {
7948 /* cur_item must be preserved */
7955 }
7956 }
7957 }